2005-04-20 Moritz Schulte <moritz@g10code.com>
[gnupg.git] / agent / command-ssh.c
index 4c13f50..133dd01 100644 (file)
  * 02111-1307, USA
  */
 
+/* Only v2 of the ssh-agent protocol is implemented.  */
+
 #include <config.h>
-#include <stdint.h>
+
+#include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <errno.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <dirent.h>
-#include <stdio.h>
+#include <assert.h>
 
 #include "agent.h"
 
-#include <gcrypt.h>
-
 #include "estream.h"
+#include "i18n.h"
 
 \f
 
 #define SSH_RESPONSE_IDENTITIES_ANSWER    12
 #define SSH_RESPONSE_SIGN_RESPONSE        14
 
-\f
+/* Other constants.  */
+#define SSH_DSA_SIGNATURE_PADDING 20
+#define SSH_DSA_SIGNATURE_ELEMS    2
+#define SPEC_FLAG_USE_PKCS1V2 (1 << 0)
+
+
+/* The blurb we put into the header of a newly created control file.  */
+static const char sshcontrolblurb[] =
+"# List of allowed ssh keys.  Only keys present in this file are used\n"
+"# in the SSH protocol.  The ssh-add tool may add new entries to this\n"
+"# file to enable them; you may also add them manually.  Comment\n"
+"# lines, like this one, as well as empty lines are ignored.  Lines do\n"
+"# have a certain length limit but this is not serious limitation as\n" 
+"# the format of the entries is fixed and checked by gpg-agent. A\n"
+"# non-comment line starts with optional white spaces, followed by the\n"
+"# keygrip of the key given as 40 hex digits, optionally followed by a\n"
+"# the caching TTL in seconds and another optional field for arbitrary\n"
+"# flags.   Prepend the keygrip with an '!' mark to disable it.\n"
+"\n";
+
 
 
-/* Basic types.  */
+/* Macros.  */
+
+/* Return a new uint32 with b0 being the most significant byte and b3
+   being the least significant byte.  */
+#define uint32_construct(b0, b1, b2, b3) \
+  ((b0 << 24) | (b1 << 16) | (b2 << 8) | b3)
+
+\f
+
 
-/* A "byte".  */
-typedef unsigned char byte_t;
+/*
+ * Basic types.
+ */
 
-typedef int (*ssh_request_handler_t) (ctrl_t ctrl,
-                                     estream_t request, estream_t response);
+/* Type for a request handler.  */
+typedef gpg_error_t (*ssh_request_handler_t) (ctrl_t ctrl,
+                                             estream_t request,
+                                             estream_t response);
 
+/* Type, which is used for associating request handlers with the
+   appropriate request IDs.  */
 typedef struct ssh_request_spec
 {
-  byte_t type;
+  unsigned char type;
   ssh_request_handler_t handler;
+  const char *identifier;
+  unsigned int secret_input;
 } ssh_request_spec_t;
 
-typedef gpg_error_t (*ssh_key_modifier_t) (const char *elems, gcry_mpi_t *mpis);
+/* Type for "key modifier functions", which are necessary since
+   OpenSSH and GnuPG treat key material slightly different.  A key
+   modifier is called right after a new key identity has been received
+   in order to "sanitize" the material.  */
+typedef gpg_error_t (*ssh_key_modifier_t) (const char *elems,
+                                           gcry_mpi_t *mpis);
+
+/* The encoding of a generated signature is dependent on the
+   algorithm; therefore algorithm specific signature encoding
+   functions are necessary.  */
 typedef gpg_error_t (*ssh_signature_encoder_t) (estream_t signature_blob,
                                                gcry_mpi_t *mpis);
 
+/* Type, which is used for boundling all the algorithm specific
+   information together in a single object.  */
 typedef struct ssh_key_type_spec
 {
+  /* Algorithm identifier as used by OpenSSH.  */
   const char *ssh_identifier;
+
+  /* Algorithm identifier as used by GnuPG.  */
   const char *identifier;
+
+  /* List of MPI names for secret keys; order matches the one of the
+     agent protocol.  */
   const char *elems_key_secret;
+
+  /* List of MPI names for public keys; order matches the one of the
+     agent protocol.  */
   const char *elems_key_public;
-  const char *elems_secret;
+
+  /* List of MPI names for signature data.  */
   const char *elems_signature;
+
+  /* List of MPI names for secret keys; order matches the one, which
+     is required by gpg-agent's key access layer.  */
   const char *elems_sexp_order;
+
+  /* Key modifier function.  */
   ssh_key_modifier_t key_modifier;
+
+  /* Signature encoder function.  */
   ssh_signature_encoder_t signature_encoder;
+
+  /* Misc flags.  */
   unsigned int flags;
 } ssh_key_type_spec_t;
 
+
+/* Prototypes.  */
+static gpg_error_t ssh_handler_request_identities (ctrl_t ctrl,
+                                                  estream_t request,
+                                                  estream_t response);
+static gpg_error_t ssh_handler_sign_request (ctrl_t ctrl,
+                                            estream_t request,
+                                            estream_t response);
+static gpg_error_t ssh_handler_add_identity (ctrl_t ctrl,
+                                            estream_t request,
+                                            estream_t response);
+static gpg_error_t ssh_handler_remove_identity (ctrl_t ctrl,
+                                               estream_t request,
+                                               estream_t response);
+static gpg_error_t ssh_handler_remove_all_identities (ctrl_t ctrl,
+                                                     estream_t request,
+                                                     estream_t response);
+static gpg_error_t ssh_handler_lock (ctrl_t ctrl,
+                                    estream_t request,
+                                    estream_t response);
+static gpg_error_t ssh_handler_unlock (ctrl_t ctrl,
+                                      estream_t request,
+                                      estream_t response);
+
+static gpg_error_t ssh_key_modifier_rsa (const char *elems, gcry_mpi_t *mpis);
+static gpg_error_t ssh_signature_encoder_rsa (estream_t signature_blob,
+                                              gcry_mpi_t *mpis);
+static gpg_error_t ssh_signature_encoder_dsa (estream_t signature_blob,
+                                              gcry_mpi_t *mpis);
+
+
+
+/* Global variables.  */
+   
+
+/* Associating request types with the corresponding request
+   handlers.  */
+
+#define REQUEST_SPEC_DEFINE(id, name, secret_input) \
+  { SSH_REQUEST_##id, ssh_handler_##name, #name, secret_input }
+
+static ssh_request_spec_t request_specs[] =
+  {
+    REQUEST_SPEC_DEFINE (REQUEST_IDENTITIES,    request_identities,    1),
+    REQUEST_SPEC_DEFINE (SIGN_REQUEST,          sign_request,          0),
+    REQUEST_SPEC_DEFINE (ADD_IDENTITY,          add_identity,          1),
+    REQUEST_SPEC_DEFINE (ADD_ID_CONSTRAINED,    add_identity,          1),
+    REQUEST_SPEC_DEFINE (REMOVE_IDENTITY,       remove_identity,       0),
+    REQUEST_SPEC_DEFINE (REMOVE_ALL_IDENTITIES, remove_all_identities, 0),
+    REQUEST_SPEC_DEFINE (LOCK,                  lock,                  0),
+    REQUEST_SPEC_DEFINE (UNLOCK,                unlock,                0)
+  };
+#undef REQUEST_SPEC_DEFINE
+
+
+/* Table holding key type specifications.  */
+static ssh_key_type_spec_t ssh_key_types[] =
+  {
+    {
+      "ssh-rsa", "rsa", "nedupq", "en",   "s",  "nedpqu",
+      ssh_key_modifier_rsa, ssh_signature_encoder_rsa,
+      SPEC_FLAG_USE_PKCS1V2
+    },
+    {
+      "ssh-dss", "dsa", "pqgyx",  "pqgy", "rs", "pqgyx",
+      NULL,                 ssh_signature_encoder_dsa,
+      0
+    },
+  };
+
 \f
 
-static uint32_t lifetime_default;
 
-/* General utility functions.  */
 
+/*
+   General utility functions. 
+ */
+
+/* A secure realloc, i.e. it makes sure to allocate secure memory if A
+   is NULL.  This is required because the standard gcry_realloc does
+   not know whether to allocate secure or normal if NULL is passed as
+   existing buffer.  */
 static void *
 realloc_secure (void *a, size_t n)
 {
@@ -107,14 +249,39 @@ realloc_secure (void *a, size_t n)
     p = gcry_realloc (a, n);
   else
     p = gcry_malloc_secure (n);
-  
+
   return p;
 }
 
-/* Primitive I/O functions.  */
 
+/* Create and return a new C-string from DATA/DATA_N (i.e.: add
+   NUL-termination); return NULL on OOM.  */
+static char *
+make_cstring (const char *data, size_t data_n)
+{
+  char *s;
+
+  s = xtrymalloc (data_n + 1);
+  if (s)
+    {
+      strncpy (s, data, data_n);
+      s[data_n] = 0;
+    }
+
+  return s;
+}
+
+
+
+
+/* 
+   Primitive I/O functions.  
+ */
+
+
+/* Read a byte from STREAM, store it in B.  */
 static gpg_error_t
-es_read_byte (estream_t stream, byte_t *b)
+stream_read_byte (estream_t stream, unsigned char *b)
 {
   gpg_error_t err;
   int ret;
@@ -136,8 +303,9 @@ es_read_byte (estream_t stream, byte_t *b)
   return err;
 }
 
+/* Write the byte contained in B to STREAM.  */
 static gpg_error_t
-es_write_byte (estream_t stream, byte_t b)
+stream_write_byte (estream_t stream, unsigned char b)
 {
   gpg_error_t err;
   int ret;
@@ -151,8 +319,9 @@ es_write_byte (estream_t stream, byte_t b)
   return err;
 }
 
+/* Read a uint32 from STREAM, store it in UINT32.  */
 static gpg_error_t
-es_read_uint32 (estream_t stream, uint32_t *uint32)
+stream_read_uint32 (estream_t stream, u32 *uint32)
 {
   unsigned char buffer[4];
   size_t bytes_read;
@@ -168,13 +337,9 @@ es_read_uint32 (estream_t stream, uint32_t *uint32)
        err = gpg_error (GPG_ERR_EOF);
       else
        {
-         uint32_t n;
+         u32 n;
 
-         n = (0
-              | ((uint32_t) (buffer[0] << 24))
-              | ((uint32_t) (buffer[1] << 16))
-              | ((uint32_t) (buffer[2] <<  8))
-              | ((uint32_t) (buffer[3] <<  0)));
+         n = uint32_construct (buffer[0], buffer[1], buffer[2], buffer[3]);
          *uint32 = n;
          err = 0;
        }
@@ -183,17 +348,18 @@ es_read_uint32 (estream_t stream, uint32_t *uint32)
   return err;
 }
 
+/* Write the uint32 contained in UINT32 to STREAM.  */
 static gpg_error_t
-es_write_uint32 (estream_t stream, uint32_t uint32)
+stream_write_uint32 (estream_t stream, u32 uint32)
 {
   unsigned char buffer[4];
   gpg_error_t err;
   int ret;
 
-  buffer[0] = (uint32 >> 24) & 0xFF;
-  buffer[1] = (uint32 >> 16) & 0xFF;
-  buffer[2] = (uint32 >>  8) & 0xFF;
-  buffer[3] = (uint32 >>  0) & 0xFF;
+  buffer[0] = uint32 >> 24;
+  buffer[1] = uint32 >> 16;
+  buffer[2] = uint32 >>  8;
+  buffer[3] = uint32 >>  0;
 
   ret = es_write (stream, buffer, sizeof (buffer), NULL);
   if (ret)
@@ -204,8 +370,9 @@ es_write_uint32 (estream_t stream, uint32_t uint32)
   return err;
 }
 
+/* Read SIZE bytes from STREAM into BUFFER.  */
 static gpg_error_t
-es_read_data (estream_t stream, unsigned char *buffer, size_t size)
+stream_read_data (estream_t stream, unsigned char *buffer, size_t size)
 {
   gpg_error_t err;
   size_t bytes_read;
@@ -225,8 +392,9 @@ es_read_data (estream_t stream, unsigned char *buffer, size_t size)
   return err;
 }
 
+/* Write SIZE bytes from BUFFER to STREAM.  */
 static gpg_error_t
-es_write_data (estream_t stream, const unsigned char *buffer, size_t size)
+stream_write_data (estream_t stream, const unsigned char *buffer, size_t size)
 {
   gpg_error_t err;
   int ret;
@@ -240,18 +408,21 @@ es_write_data (estream_t stream, const unsigned char *buffer, size_t size)
   return err;
 }
 
+/* Read a binary string from STREAM into STRING, store size of string
+   in STRING_SIZE; depending on SECURE use secure memory for
+   string.  */
 static gpg_error_t
-es_read_string (estream_t stream, unsigned int secure,
-               unsigned char **string, uint32_t *string_size)
+stream_read_string (estream_t stream, unsigned int secure,
+                   unsigned char **string, u32 *string_size)
 {
   gpg_error_t err;
   unsigned char *buffer;
-  uint32_t length;
+  u32 length;
 
   buffer = NULL;
 
   /* Read string length.  */
-  err = es_read_uint32 (stream, &length);
+  err = stream_read_uint32 (stream, &length);
   if (err)
     goto out;
 
@@ -262,14 +433,12 @@ es_read_string (estream_t stream, unsigned int secure,
     buffer = xtrymalloc (length + 1);
   if (! buffer)
     {
-      /* FIXME: xtrymalloc_secure does not set errno, does it?  */
       err = gpg_error_from_errno (errno);
-      abort ();
       goto out;
     }
 
   /* Read data.  */
-  err = es_read_data (stream, buffer, length);
+  err = stream_read_data (stream, buffer, length);
   if (err)
     goto out;
 
@@ -287,13 +456,14 @@ es_read_string (estream_t stream, unsigned int secure,
   return err;
 }
 
+/* Read a C-string from STREAM, store copy in STRING.  */
 static gpg_error_t
-es_read_cstring (estream_t stream, char **string)
+stream_read_cstring (estream_t stream, char **string)
 {
   unsigned char *buffer;
   gpg_error_t err;
 
-  err = es_read_string (stream, 0, &buffer, NULL);
+  err = stream_read_string (stream, 0, &buffer, NULL);
   if (err)
     goto out;
   
@@ -304,45 +474,50 @@ es_read_cstring (estream_t stream, char **string)
   return err;
 }
 
+
+/* Write a binary string from STRING of size STRING_N to STREAM.  */
 static gpg_error_t
-es_write_string (estream_t stream,
-                const unsigned char *string, uint32_t string_n)
+stream_write_string (estream_t stream,
+                    const unsigned char *string, u32 string_n)
 {
   gpg_error_t err;
 
-  err = es_write_uint32 (stream, string_n);
+  err = stream_write_uint32 (stream, string_n);
   if (err)
     goto out;
 
-  err = es_write_data (stream, string, string_n);
+  err = stream_write_data (stream, string, string_n);
 
  out:
 
   return err;
 }
 
+/* Write a C-string from STRING to STREAM.  */
 static gpg_error_t
-es_write_cstring (estream_t stream, const char *string)
+stream_write_cstring (estream_t stream, const char *string)
 {
   gpg_error_t err;
 
-  err = es_write_string (stream,
-                        (const unsigned char *) string, strlen (string));
+  err = stream_write_string (stream,
+                            (const unsigned char *) string, strlen (string));
 
   return err;
 }                        
 
+/* Read an MPI from STREAM, store it in MPINT.  Depending on SECURE
+   use secure memory.  */
 static gpg_error_t
-es_read_mpi (estream_t stream, unsigned int secure, gcry_mpi_t *mpint)
+stream_read_mpi (estream_t stream, unsigned int secure, gcry_mpi_t *mpint)
 {
   unsigned char *mpi_data;
-  uint32_t mpi_data_size;
+  u32 mpi_data_size;
   gpg_error_t err;
   gcry_mpi_t mpi;
 
   mpi_data = NULL;
 
-  err = es_read_string (stream, secure, &mpi_data, &mpi_data_size);
+  err = stream_read_string (stream, secure, &mpi_data, &mpi_data_size);
   if (err)
     goto out;
 
@@ -359,8 +534,9 @@ es_read_mpi (estream_t stream, unsigned int secure, gcry_mpi_t *mpint)
   return err;
 }
 
+/* Write the MPI contained in MPINT to STREAM.  */
 static gpg_error_t
-es_write_mpi (estream_t stream, gcry_mpi_t mpint)
+stream_write_mpi (estream_t stream, gcry_mpi_t mpint)
 {
   unsigned char *mpi_buffer;
   size_t mpi_buffer_n;
@@ -372,7 +548,7 @@ es_write_mpi (estream_t stream, gcry_mpi_t mpint)
   if (err)
     goto out;
 
-  err = es_write_string (stream, mpi_buffer, mpi_buffer_n);
+  err = stream_write_string (stream, mpi_buffer, mpi_buffer_n);
 
  out:
 
@@ -381,8 +557,42 @@ es_write_mpi (estream_t stream, gcry_mpi_t mpint)
   return err;
 }
 
+/* Copy data from SRC to DST until EOF is reached.  */
+static gpg_error_t
+stream_copy (estream_t dst, estream_t src)
+{
+  char buffer[BUFSIZ];
+  size_t bytes_read;
+  gpg_error_t err;
+  int ret;
+
+  err = 0;
+  while (1)
+    {
+      ret = es_read (src, buffer, sizeof (buffer), &bytes_read);
+      if (ret || (! bytes_read))
+       {
+         if (ret)
+           err = gpg_error_from_errno (errno);
+         break;
+       }
+      ret = es_write (dst, buffer, bytes_read, NULL);
+      if (ret)
+       {
+         err = gpg_error_from_errno (errno);
+         break;
+       }
+    }
+
+  return err;
+}
+
+
+/* Read the content of the file specified by FILENAME into a newly
+   create buffer, which is to be stored in BUFFER; store length of
+   buffer in BUFFER_N.  */
 static gpg_error_t
-es_read_file (const char *filename, unsigned char **buffer, size_t *buffer_n)
+file_to_buffer (const char *filename, unsigned char **buffer, size_t *buffer_n)
 {
   unsigned char *buffer_new;
   struct stat statbuf;
@@ -414,7 +624,7 @@ es_read_file (const char *filename, unsigned char **buffer, size_t *buffer_n)
       goto out;
     }
 
-  err = es_read_data (stream, buffer_new, statbuf.st_size);
+  err = stream_read_data (stream, buffer_new, statbuf.st_size);
   if (err)
     goto out;
 
@@ -432,39 +642,167 @@ es_read_file (const char *filename, unsigned char **buffer, size_t *buffer_n)
   return err;
 }
 
+
+
+\f
+/* Open the ssh control file and create it if not available. With
+   APPEND passed as true the file will be opened in append mode,
+   otherwise in read only mode.  On success a file pointer is stored
+   at the address of R_FP. */
 static gpg_error_t
-es_copy (estream_t dst, estream_t src)
+open_control_file (FILE **r_fp, int append)
 {
-  char buffer[BUFSIZ];
-  size_t bytes_read;
   gpg_error_t err;
-  int ret;
+  char *fname;
+  FILE *fp;
+
+  /* Note: As soon as we start to use non blocking functions here
+     (i.e. where Pth might switch threads) we need to employ a
+     mutex.  */
+  *r_fp = NULL;
+  fname = make_filename (opt.homedir, "sshcontrol", NULL);
+  /* FIXME: With "a+" we are not able to check whether this will will
+     be created and thus the blurb needs to be written first.  */
+  fp = fopen (fname, append? "a+":"r");
+  if (!fp && errno == ENOENT)
+    {
+      /* Fixme: "x" is a GNU extension.  We might want to use the es_
+         functions here.  */
+      fp = fopen (fname, "wx");  
+      if (!fp)
+        {
+          err = gpg_error (gpg_err_code_from_errno (errno));
+          log_error (_("can't create `%s': %s\n"), fname, gpg_strerror (err));
+          xfree (fname);
+          return err;
+        }
+      fputs (sshcontrolblurb, fp);
+      fclose (fp);
+      fp = fopen (fname, append? "a+":"r");
+    }
+
+  if (!fp)
+    {
+      err = gpg_error (gpg_err_code_from_errno (errno));
+      log_error (_("can't open `%s': %s\n"), fname, gpg_strerror (err));
+      xfree (fname);
+      return err;
+    }
+  
+  *r_fp = fp;  
 
-  err = 0;
-  while (1)
+  return 0;
+}
+
+
+/* Search the file at stream FP from the beginning until a matching
+   HEXGRIP is found; return success in this case and store true at
+   DISABLED if the found key has been disabled.  */
+static gpg_error_t
+search_control_file (FILE *fp, const char *hexgrip, int *disabled)
+{
+  int c, i;
+  char *p, line[256];
+  
+  assert (strlen (hexgrip) == 40 );
+
+  rewind (fp);
+  *disabled = 0;
+ next_line:
+  do
+    {
+      if (!fgets (line, DIM(line)-1, fp) )
+        {
+          if (feof (fp))
+            return gpg_error (GPG_ERR_EOF);
+          return gpg_error (gpg_err_code_from_errno (errno));
+        }
+      
+      if (!*line || line[strlen(line)-1] != '\n')
+        {
+          /* Eat until end of line */
+          while ( (c=getc (fp)) != EOF && c != '\n')
+            ;
+          return gpg_error (*line? GPG_ERR_LINE_TOO_LONG
+                                 : GPG_ERR_INCOMPLETE_LINE);
+        }
+      
+      /* Allow for empty lines and spaces */
+      for (p=line; spacep (p); p++)
+        ;
+    }
+  while (!*p || *p == '\n' || *p == '#');
+  
+  *disabled = 0;
+  if (*p == '!')
     {
-      ret = es_read (src, buffer, sizeof (buffer), &bytes_read);
-      if (ret || (! bytes_read))
-       {
-         if (ret)
-           err = gpg_error_from_errno (errno);
-         break;
-       }
-      ret = es_write (dst, buffer, bytes_read, NULL);
-      if (ret)
-       {
-         err = gpg_error_from_errno (errno);
-         break;
-       }
+      *disabled = 1;
+      for (p++; spacep (p); p++)
+        ;
     }
 
-  return err;
+  for (i=0; hexdigitp (p) && i < 40; p++, i++)
+    if (hexgrip[i] != (*p >= 'a'? (*p & 0xdf): *p))
+      goto next_line;
+  if (i != 40 || !(spacep (p) || *p == '\n'))
+    {
+      log_error ("invalid formatted line in ssh control file\n");
+      return gpg_error (GPG_ERR_BAD_DATA);
+    }
+
+  /* Fixme: Get TTL and flags.  */
+
+  return 0; /* Okay:  found it.  */
+}
+
+
+
+/* Add an entry to the control file to mark the key with the keygrip
+   HEXGRIP as usable for SSH; i.e. it will be returned when ssh asks
+   for it.  This function is in general used to add a key received
+   through the ssh-add function.  We can assume that the user wants to
+   allow ssh using this key. */
+static gpg_error_t
+add_control_entry (ctrl_t ctrl, const char *hexgrip, int ttl)
+{
+  gpg_error_t err;
+  FILE *fp;
+  int disabled;
+
+  err = open_control_file (&fp, 1);
+  if (err)
+    return err;
+
+  err = search_control_file (fp, hexgrip, &disabled);
+  if (err && gpg_err_code(err) == GPG_ERR_EOF)
+    {
+      struct tm *tp;
+      time_t atime = time (NULL);
+
+      /* Not yet in the file - add it. Becuase the file has been
+         opened in append mode, we simply need to write to it.  */
+      tp = localtime (&atime);
+      fprintf (fp, "# Key added on %04d-%02d-%02d %02d:%02d:%02d\n%s %d\n",
+               1900+tp->tm_year, tp->tm_mon+1, tp->tm_mday,
+               tp->tm_hour, tp->tm_min, tp->tm_sec,
+               hexgrip, ttl);
+               
+    }
+  fclose (fp);
+  return 0;
 }
 
+
+
 \f
 
-/* MPI lists.  */
+/*
+
+  MPI lists. 
+
+ */
 
+/* Free the list of MPIs MPI_LIST.  */
 static void
 mpint_list_free (gcry_mpi_t *mpi_list)
 {
@@ -478,33 +816,32 @@ mpint_list_free (gcry_mpi_t *mpi_list)
     }
 }
 
+
 static gpg_error_t
 ssh_receive_mpint_list (estream_t stream, int secret,
                        ssh_key_type_spec_t key_spec, gcry_mpi_t **mpi_list)
 {
-  const char *elems_secret;
-  const char *elems;
+  unsigned int elems_public_n;
+  const char *elems_public;
   unsigned int elems_n;
+  const char *elems;
+  int elem_is_secret;
   gcry_mpi_t *mpis;
-  unsigned int i;
   gpg_error_t err;
-  int elem_is_secret;
+  unsigned int i;
 
   mpis = NULL;
   err = 0;
   
   if (secret)
-    {
-      elems = key_spec.elems_key_secret;
-      elems_secret = key_spec.elems_secret;
-    }
+    elems = key_spec.elems_key_secret;
   else
-    {
-      elems = key_spec.elems_key_public;
-      elems_secret = "";
-    }
+    elems = key_spec.elems_key_public;
   elems_n = strlen (elems);
 
+  elems_public = key_spec.elems_key_public;
+  elems_public_n = strlen (elems_public);
+
   mpis = xtrymalloc (sizeof (*mpis) * (elems_n + 1));
   if (! mpis)
     {
@@ -513,11 +850,13 @@ ssh_receive_mpint_list (estream_t stream, int secret,
     }
   
   memset (mpis, 0, sizeof (*mpis) * (elems_n + 1));
-  
+
+  elem_is_secret = 0;
   for (i = 0; i < elems_n; i++)
     {
-      elem_is_secret = strchr (elems_secret, elems[i]) ? 1 : 0;
-      err = es_read_mpi (stream, elem_is_secret, &mpis[i]);
+      if (secret)
+       elem_is_secret = ! strchr (elems_public, elems[i]);
+      err = stream_read_mpi (stream, elem_is_secret, &mpis[i]);
       if (err)
        break;
     }
@@ -536,6 +875,7 @@ ssh_receive_mpint_list (estream_t stream, int secret,
 
 \f
 
+/* Key modifier function for RSA.  */
 static gpg_error_t
 ssh_key_modifier_rsa (const char *elems, gcry_mpi_t *mpis)
 {
@@ -569,6 +909,7 @@ ssh_key_modifier_rsa (const char *elems, gcry_mpi_t *mpis)
   return 0;
 }
 
+/* Signature encoder function for RSA.  */
 static gpg_error_t
 ssh_signature_encoder_rsa (estream_t signature_blob, gcry_mpi_t *mpis)
 {
@@ -583,7 +924,7 @@ ssh_signature_encoder_rsa (estream_t signature_blob, gcry_mpi_t *mpis)
   if (err)
     goto out;
 
-  err = es_write_string (signature_blob, data, data_n);
+  err = stream_write_string (signature_blob, data, data_n);
   xfree (data);
 
  out:
@@ -591,9 +932,8 @@ ssh_signature_encoder_rsa (estream_t signature_blob, gcry_mpi_t *mpis)
   return err;
 }
 
-#define SSH_DSA_SIGNATURE_PADDING 20
-#define SSH_DSA_SIGNATURE_ELEMS    2
 
+/* Signature encoder function for DSA.  */
 static gpg_error_t
 ssh_signature_encoder_dsa (estream_t signature_blob, gcry_mpi_t *mpis)
 {
@@ -628,7 +968,7 @@ ssh_signature_encoder_dsa (estream_t signature_blob, gcry_mpi_t *mpis)
   if (err)
     goto out;
 
-  err = es_write_string (signature_blob, buffer, sizeof (buffer));
+  err = stream_write_string (signature_blob, buffer, sizeof (buffer));
 
  out:
 
@@ -637,33 +977,18 @@ ssh_signature_encoder_dsa (estream_t signature_blob, gcry_mpi_t *mpis)
   return err;
 }
 
-#define SPEC_FLAG_USE_PKCS1V2 (1 << 0)
-
-
-/* Table holding key type specifications.  */
-static ssh_key_type_spec_t ssh_key_types[] =
-  {
-    {
-      "ssh-rsa", "rsa", "nedupq", "en",   "dupq", "s",  "nedpqu",
-      ssh_key_modifier_rsa, ssh_signature_encoder_rsa,
-      SPEC_FLAG_USE_PKCS1V2
-    },
-    {
-      "ssh-dss", "dsa", "pqgyx",  "pqgy", "x",    "rs", "pqgyx",
-      NULL,                 ssh_signature_encoder_dsa,
-      0
-    },
-  };
-
-\f
+/* 
+   S-Expressions. 
+ */
 
-/* S-Expressions.  */
 
+/*  */
 static gpg_error_t
-ssh_sexp_construct (gcry_sexp_t *sexp,
+sexp_key_construct (gcry_sexp_t *sexp,
                    ssh_key_type_spec_t key_spec, int secret,
                    gcry_mpi_t *mpis, const char *comment)
 {
+  const char *key_identifier[] = { "public-key", "private-key" };
   gcry_sexp_t sexp_new;
   char *sexp_template;
   size_t sexp_template_n;
@@ -683,7 +1008,15 @@ ssh_sexp_construct (gcry_sexp_t *sexp,
     elems = key_spec.elems_key_public;
   elems_n = strlen (elems);
 
-  sexp_template_n = 33 + strlen (key_spec.identifier) + (elems_n * 6) - (! secret);
+  /*
+    Calculate size for sexp_template_n:
+
+    "(%s(%s<mpis>)(comment%s))" -> 20 + sizeof (<mpis>).
+
+    mpi: (X%m) -> 5.
+
+  */
+  sexp_template_n = 20 + (elems_n * 5);
   sexp_template = xtrymalloc (sexp_template_n);
   if (! sexp_template)
     {
@@ -691,18 +1024,25 @@ ssh_sexp_construct (gcry_sexp_t *sexp,
       goto out;
     }
 
-  arg_list = xtrymalloc (sizeof (*arg_list) * (elems_n + 1));
+  /* Key identifier, algorithm identifier, mpis, comment.  */
+  arg_list = xtrymalloc (sizeof (*arg_list) * (2 + elems_n + 1));
   if (! arg_list)
     {
       err = gpg_error_from_errno (errno);
       goto out;
     }
 
-  sprintf (sexp_template, "(%s-key (%s ",
-          secret ? "private" : "public", key_spec.identifier);
+  i = 0;
+  arg_list[i++] = &key_identifier[secret];
+  arg_list[i++] = &key_spec.identifier;
+
+  *sexp_template = 0;
+  sexp_template_n = 0;
+  sexp_template_n = sprintf (sexp_template + sexp_template_n, "(%%s(%%s");
   for (i = 0; i < elems_n; i++)
     {
-      sprintf (strchr (sexp_template, 0), "(%c %%m)", elems[i]);
+      sexp_template_n += sprintf (sexp_template + sexp_template_n, "(%c%%m)",
+                                 elems[i]);
       if (secret)
        {
          for (j = 0; j < elems_n; j++)
@@ -711,10 +1051,12 @@ ssh_sexp_construct (gcry_sexp_t *sexp,
        }
       else
        j = i;
-      arg_list[i] = &mpis[j];
+      arg_list[i + 2] = &mpis[j];
     }
-  arg_list[i] = &comment;
-  sprintf (strchr (sexp_template, 0), ") (comment %%s))");
+  sexp_template_n += sprintf (sexp_template + sexp_template_n,
+                             ")(comment%%s))");
+
+  arg_list[i + 2] = &comment;
 
   err = gcry_sexp_build_array (&sexp_new, NULL, sexp_template, arg_list);
   if (err)
@@ -730,10 +1072,11 @@ ssh_sexp_construct (gcry_sexp_t *sexp,
   return err;
 }
 
+
 static gpg_error_t
-ssh_sexp_extract (gcry_sexp_t sexp,
+sexp_key_extract (gcry_sexp_t sexp,
                  ssh_key_type_spec_t key_spec, int *secret,
-                 gcry_mpi_t **mpis, const char **comment)
+                 gcry_mpi_t **mpis, char **comment)
 {
   gpg_error_t err;
   gcry_sexp_t value_list;
@@ -763,13 +1106,14 @@ ssh_sexp_extract (gcry_sexp_t sexp,
       goto out;
     }
 
-  if ((data_n == 10) && (! strncmp (data, "public-key", 10)))
+  if ((data_n == 10 && !strncmp (data, "public-key", 10))
+      || (data_n == 21 && !strncmp (data, "protected-private-key", 21))
+      || (data_n == 20 && !strncmp (data, "shadowed-private-key", 20)))
     {
       is_secret = 0;
       elems = key_spec.elems_key_public;
     }
-  else if (((data_n == 11) && (! strncmp (data, "private-key", 11)))
-          || ((data_n == 21) && (! strncmp (data, "protected-private-key", 21))))
+  else if (data_n == 11 && !strncmp (data, "private-key", 11))
     {
       is_secret = 1;
       elems = key_spec.elems_key_secret;
@@ -784,7 +1128,7 @@ ssh_sexp_extract (gcry_sexp_t sexp,
   mpis_new = xtrymalloc (sizeof (*mpis_new) * (elems_n + 1));
   if (! mpis_new)
     {
-      err = gpg_error_from_errno (errno); /* FIXME, xtrymalloc+errno.  */
+      err = gpg_error_from_errno (errno);
       goto out;
     }
   memset (mpis_new, 0, sizeof (*mpis_new) * (elems_n + 1));
@@ -805,7 +1149,9 @@ ssh_sexp_extract (gcry_sexp_t sexp,
          break;
        }
 
-      mpi = gcry_sexp_nth_mpi (value_pair, 1, GCRYMPI_FMT_USG);
+      /* Note that we need to use STD format; i.e. prepend a 0x00 to
+         indicate a positive number if the high bit is set. */
+      mpi = gcry_sexp_nth_mpi (value_pair, 1, GCRYMPI_FMT_STD);
       if (! mpi)
        {
          err = gpg_error (GPG_ERR_INV_SEXP);
@@ -831,14 +1177,12 @@ ssh_sexp_extract (gcry_sexp_t sexp,
       data_n = 6;
     }
 
-  comment_new = xtrymalloc (data_n + 1);
+  comment_new = make_cstring (data, data_n);
   if (! comment_new)
     {
       err = gpg_error_from_errno (errno);
       goto out;
     }
-  strncpy (comment_new, data, data_n);
-  comment_new[data_n] = 0;
 
   if (secret)
     *secret = is_secret;
@@ -860,17 +1204,19 @@ ssh_sexp_extract (gcry_sexp_t sexp,
   return err;
 }
 
+/* Extract the car from SEXP, and create a newly created C-string 
+   which is to be stored in IDENTIFIER.  */
 static gpg_error_t
-ssh_sexp_extract_key_type (gcry_sexp_t sexp, const char **key_type)
+sexp_extract_identifier (gcry_sexp_t sexp, char **identifier)
 {
+  char *identifier_new;
   gcry_sexp_t sublist;
-  char *key_type_new;
   const char *data;
   size_t data_n;
   gpg_error_t err;
 
+  identifier_new = NULL;
   err = 0;
-  key_type_new = NULL;
   
   sublist = gcry_sexp_nth (sexp, 1);
   if (! sublist)
@@ -886,16 +1232,14 @@ ssh_sexp_extract_key_type (gcry_sexp_t sexp, const char **key_type)
       goto out;
     }
 
-  key_type_new = xtrymalloc (data_n + 1);
-  if (! key_type_new)
+  identifier_new = make_cstring (data, data_n);
+  if (! identifier_new)
     {
-      err = gpg_error_from_errno (errno);
+      err = gpg_err_code_from_errno (errno);
       goto out;
     }
 
-  strncpy (key_type_new, data, data_n);
-  key_type_new[data_n] = 0;
-  *key_type = key_type_new;
+  *identifier = identifier_new;
 
  out:
 
@@ -906,8 +1250,16 @@ ssh_sexp_extract_key_type (gcry_sexp_t sexp, const char **key_type)
 
 \f
 
-/* Key I/O.  */
+/*
+
+  Key I/O.
 
+*/
+
+/* Search for a key specification entry.  If SSH_NAME is not NULL,
+   search for an entry whose "ssh_name" is equal to SSH_NAME;
+   otherwise, search for an entry whose "name" is equal to NAME.
+   Store found entry in SPEC on success, return error otherwise.  */
 static gpg_error_t
 ssh_key_type_lookup (const char *ssh_name, const char *name,
                     ssh_key_type_spec_t *spec)
@@ -931,9 +1283,14 @@ ssh_key_type_lookup (const char *ssh_name, const char *name,
   return err;
 }
 
+/* Receive a key from STREAM, according to the key specification given
+   as KEY_SPEC.  Depending on SECRET, receive a secret or a public
+   key.  If READ_COMMENT is true, receive a comment string as well.
+   Constructs a new S-Expression from received data and stores it in
+   KEY_NEW.  Returns zero on success or an error code.  */
 static gpg_error_t
-ssh_receive_key (estream_t stream, gcry_sexp_t *key_new, int secret, int read_comment,
-                ssh_key_type_spec_t *key_spec)
+ssh_receive_key (estream_t stream, gcry_sexp_t *key_new, int secret,
+                 int read_comment, ssh_key_type_spec_t *key_spec)
 {
   gpg_error_t err;
   char *key_type;
@@ -948,7 +1305,7 @@ ssh_receive_key (estream_t stream, gcry_sexp_t *key_new, int secret, int read_co
   comment = "";
   key = NULL;
        
-  err = es_read_cstring (stream, &key_type);
+  err = stream_read_cstring (stream, &key_type);
   if (err)
     goto out;
 
@@ -962,7 +1319,7 @@ ssh_receive_key (estream_t stream, gcry_sexp_t *key_new, int secret, int read_co
 
   if (read_comment)
     {
-      err = es_read_cstring (stream, &comment);
+      err = stream_read_cstring (stream, &comment);
       if (err)
        goto out;
     }
@@ -979,7 +1336,7 @@ ssh_receive_key (estream_t stream, gcry_sexp_t *key_new, int secret, int read_co
        goto out;
     }
 
-  err = ssh_sexp_construct (&key, spec, secret, mpi_list, comment);
+  err = sexp_key_construct (&key, spec, secret, mpi_list, comment);
   if (err)
     goto out;
 
@@ -997,6 +1354,9 @@ ssh_receive_key (estream_t stream, gcry_sexp_t *key_new, int secret, int read_co
   return err;
 }
 
+/* Converts a key of type TYPE, whose key material is given in MPIS,
+   into a newly created binary blob, which is to be stored in
+   BLOB/BLOB_SIZE.  Returns zero on success or an error code.  */
 static gpg_error_t
 ssh_convert_key_to_blob (unsigned char **blob, size_t *blob_size,
                         const char *type, gcry_mpi_t *mpis)
@@ -1018,12 +1378,12 @@ ssh_convert_key_to_blob (unsigned char **blob, size_t *blob_size,
       goto out;
     }
 
-  err = es_write_cstring (stream, type);
+  err = stream_write_cstring (stream, type);
   if (err)
     goto out;
 
   for (i = 0; mpis[i] && (! err); i++)
-    err = es_write_mpi (stream, mpis[i]);
+    err = stream_write_mpi (stream, mpis[i]);
   if (err)
     goto out;
 
@@ -1045,7 +1405,7 @@ ssh_convert_key_to_blob (unsigned char **blob, size_t *blob_size,
       goto out;
     }
 
-  err = es_read_data (stream, blob_new, blob_size_new);
+  err = stream_read_data (stream, blob_new, blob_size_new);
   if (err)
     goto out;
 
@@ -1063,13 +1423,17 @@ ssh_convert_key_to_blob (unsigned char **blob, size_t *blob_size,
 }
                              
 
+/* Write the public key KEY_PUBLIC to STREAM in SSH key format.  If
+   OVERRIDE_COMMENT is not NULL, it will be used instead of the
+   comment stored in the key.  */
 static gpg_error_t
-ssh_send_key_public (estream_t stream, gcry_sexp_t key_public)
+ssh_send_key_public (estream_t stream, gcry_sexp_t key_public,
+                     const char *override_comment)
 {
   ssh_key_type_spec_t spec;
   gcry_mpi_t *mpi_list;
-  const char *key_type;
-  const char *comment;
+  char *key_type;
+  char *comment;
   unsigned char *blob;
   size_t blob_n;
   gpg_error_t err;
@@ -1079,7 +1443,7 @@ ssh_send_key_public (estream_t stream, gcry_sexp_t key_public)
   comment = NULL;
   blob = NULL;
 
-  err = ssh_sexp_extract_key_type (key_public, &key_type);
+  err = sexp_extract_identifier (key_public, &key_type);
   if (err)
     goto out;
 
@@ -1087,30 +1451,35 @@ ssh_send_key_public (estream_t stream, gcry_sexp_t key_public)
   if (err)
     goto out;
 
-  err = ssh_sexp_extract (key_public, spec, NULL, &mpi_list, &comment);
+  err = sexp_key_extract (key_public, spec, NULL, &mpi_list, &comment);
   if (err)
     goto out;
 
-  err = ssh_convert_key_to_blob (&blob, &blob_n, spec.ssh_identifier, mpi_list);
+  err = ssh_convert_key_to_blob (&blob, &blob_n,
+                                 spec.ssh_identifier, mpi_list);
   if (err)
     goto out;
   
-  err = es_write_string (stream, blob, blob_n);
+  err = stream_write_string (stream, blob, blob_n);
   if (err)
     goto out;
 
-  err = es_write_cstring (stream, comment);
+  err = stream_write_cstring (stream,
+                              override_comment? override_comment : comment);
   
  out:
 
   mpint_list_free (mpi_list);
-  xfree ((void *) key_type);
-  xfree ((void *) comment);
+  xfree (key_type);
+  xfree (comment);
   xfree (blob);
 
   return err;
 }
 
+/* Read a public key out of BLOB/BLOB_SIZE according to the key
+   specification given as KEY_SPEC, storing the new key in KEY_PUBLIC.
+   Returns zero on success or an error code.  */
 static gpg_error_t
 ssh_read_key_public_from_blob (unsigned char *blob, size_t blob_size,
                               gcry_sexp_t *key_public,
@@ -1128,7 +1497,7 @@ ssh_read_key_public_from_blob (unsigned char *blob, size_t blob_size,
       goto out;
     }
 
-  err = es_write_data (blob_stream, blob, blob_size);
+  err = stream_write_data (blob_stream, blob, blob_size);
   if (err)
     goto out;
 
@@ -1148,147 +1517,210 @@ ssh_read_key_public_from_blob (unsigned char *blob, size_t blob_size,
 
 \f
 
+/* Converts the secret key KEY_SECRET into a public key, storing it in
+   KEY_PUBLIC.  SPEC is the according key specification.  Returns zero
+   on success or an error code.  */
 static gpg_error_t
 key_secret_to_public (gcry_sexp_t *key_public,
                      ssh_key_type_spec_t spec, gcry_sexp_t key_secret)
 {
-  gpg_error_t err;
-  gcry_sexp_t value_pair;
-  unsigned int i;
-  gcry_mpi_t *mpis;
-  gcry_mpi_t mpi;
-  void **arglist;
-  size_t elems_n;
-  char *template;
-  size_t template_n;
-  const char *elems;
   char *comment;
-  const char *data;
-  size_t data_n;
+  gcry_mpi_t *mpis;
+  gpg_error_t err;
+  int is_secret;
 
-  err = 0;
-  mpis = NULL;
-  arglist = NULL;
   comment = NULL;
-  template = NULL;
-  value_pair = NULL;
+  mpis = NULL;
 
-  elems = spec.elems_key_public;
-  elems_n = strlen (elems);
+  err = sexp_key_extract (key_secret, spec, &is_secret, &mpis, &comment);
+  if (err)
+    goto out;
 
-  data = NULL;
-  value_pair  = gcry_sexp_find_token (key_secret, "comment", 0);
-  if (value_pair)
-    data = gcry_sexp_nth_data (value_pair, 1, &data_n);
-  if (! data)
+  err = sexp_key_construct (key_public, spec, 0, mpis, comment);
+
+ out:
+
+  mpint_list_free (mpis);
+  xfree (comment);
+
+  return err;
+}
+
+
+/* Check whether a smartcard is available and whether it has a usable
+   key.  Store a copy of that key at R_PK and return 0.  If no key is
+   available store NULL at R_PK and return an error code.  If CARDSN
+   is no NULL, a string with the serial number of the card will be
+   a malloced and stored there. */
+static gpg_error_t
+card_key_available (ctrl_t ctrl, gcry_sexp_t *r_pk, char **cardsn)
+{
+  gpg_error_t err;
+  char *appname;
+  char *serialno = NULL;
+  unsigned char *pkbuf;
+  size_t pkbuflen;
+  gcry_sexp_t s_pk;
+  unsigned char grip[20];
+
+  *r_pk = NULL;
+  if (cardsn)
+    *cardsn = NULL;
+
+  /* First see whether a card is available and whether the application
+     is supported.  */
+  err = agent_card_getattr (ctrl, "APPTYPE", &appname);
+  if ( gpg_err_code (err) == GPG_ERR_CARD_REMOVED )
+    {
+      /* Ask for the serial number to reset the card.  */
+      err = agent_card_serialno (ctrl, &serialno);
+      if (err)
+        {
+          if (opt.verbose)
+            log_info (_("error getting serial number of card: %s\n"),
+                      gpg_strerror (err));
+          return err;
+        }
+      log_info (_("detected card with S/N: %s\n"), serialno);
+      err = agent_card_getattr (ctrl, "APPTYPE", &appname);
+    }
+  if (err)
+    {
+      log_error (_("error getting application type of card: %s\n"),
+                 gpg_strerror (err));
+      xfree (serialno);
+      return err;
+    }
+  if (strcmp (appname, "OPENPGP"))
     {
-      data = "";
-      data_n = 0;
+      log_info (_("card application `%s' is not supported\n"), appname);
+      xfree (appname);
+      xfree (serialno);
+      return gpg_error (GPG_ERR_NOT_SUPPORTED);
     }
+  xfree (appname);
+  appname = NULL;
 
-  comment = xtrymalloc (data_n + 1);
-  if (! comment)
+  /* Get the S/N if we don't have it yet.  Use the fast getattr method.  */
+  if (!serialno && (err = agent_card_getattr (ctrl, "SERIALNO", &serialno)) )
     {
-      err = gpg_error_from_errno (errno);
-      goto out;
+      log_error (_("error getting serial number of card: %s\n"),
+                 gpg_strerror (err));
+      return err;
     }
-  strncpy (comment, data, data_n);
-  comment[data_n] = 0;
 
-  gcry_sexp_release (value_pair);
-  value_pair = NULL;
-  
-  template_n = 29 + strlen (spec.identifier) + (elems_n * 7) + 1;
-  template = xtrymalloc (template_n);
-  if (! template)
+  /* Read the public key.  */
+  err = agent_card_readkey (ctrl, "OPENPGP.3", &pkbuf);
+  if (err)
     {
-      err = gpg_error_from_errno (errno);
-      goto out;
+      if (opt.verbose)
+        log_info (_("no suitable card key found: %s\n"), gpg_strerror (err));
+      xfree (serialno);
+      return err;
     }
 
-  mpis = xtrymalloc (sizeof (*mpis) * (elems_n + 1));
-  if (! mpis)
+  pkbuflen = gcry_sexp_canon_len (pkbuf, 0, NULL, NULL);
+  err = gcry_sexp_sscan (&s_pk, NULL, pkbuf, pkbuflen);
+  if (err)
     {
-      err = gpg_error_from_errno (errno);      /* FIXME: errno.  */
-      goto out;
+      log_error ("failed to build S-Exp from received card key: %s\n",
+                 gpg_strerror (err));
+      xfree (pkbuf);
+      xfree (serialno);
+      return err;
     }
-  memset (mpis, 0, sizeof (*mpis) * (elems_n + 1));
-
-  arglist = xtrymalloc (sizeof (*arglist) * (elems_n + 1));
-  if (! arglist)
+  
+  if ( !gcry_pk_get_keygrip (s_pk, grip) )
     {
-      err = gpg_error_from_errno (errno);
-      goto out;
+      log_debug ("error computing keygrip from received card key\n");
+      xfree (pkbuf);
+      gcry_sexp_release (s_pk);
+      xfree (serialno);
+      return gpg_error (GPG_ERR_INTERNAL);
     }
 
-  for (i = 0; i < elems_n; i++)
+  if ( agent_key_available (grip) )
     {
-      value_pair = gcry_sexp_find_token (key_secret, elems + i, 1);
-      if (! value_pair)
-       {
-         err = gpg_error (GPG_ERR_INV_SEXP);
-         break;
-       }
-      mpi = gcry_sexp_nth_mpi (value_pair, 1, GCRYMPI_FMT_USG);
-      if (! mpi)
-       {
-         err = gpg_error (GPG_ERR_INV_SEXP);
-         break;
-       }
-      gcry_sexp_release (value_pair);
-      value_pair = NULL;
-
-      mpis[i] = mpi;
-      arglist[i] = &mpis[i];
-      mpi = NULL;
-    }
-  if (err)
-    goto out;
-
-  sprintf (template, "(public-key (%s", spec.identifier);
-  for (i = 0; i < elems_n; i++)
-    sprintf (strchr (template, 0)," (%c %%m)", elems[i]);
-  sprintf (strchr (template, 0), ") (comment %%s))");
-  arglist[i] = &comment;
-
-  err = gcry_sexp_build_array (key_public, NULL, template, arglist);
-  
- out:
-
-  gcry_sexp_release (value_pair);
-  xfree (template);
-  mpint_list_free (mpis);
-  xfree (arglist);
-  xfree (comment);
-
-  return err;
+      /* (Shadow)-key is not available in our key storage.  */
+      unsigned char *shadow_info;
+      unsigned char *tmp;
+      
+      shadow_info = make_shadow_info (serialno, "OPENPGP.3");
+      if (!shadow_info)
+        {
+          err = gpg_error_from_errno (errno);
+          xfree (pkbuf);
+          gcry_sexp_release (s_pk);
+          xfree (serialno);
+          return err;
+        }
+      err = agent_shadow_key (pkbuf, shadow_info, &tmp);
+      xfree (shadow_info);
+      if (err)
+        {
+          log_error (_("shadowing the key failed: %s\n"), gpg_strerror (err));
+          xfree (pkbuf);
+          gcry_sexp_release (s_pk);
+          xfree (serialno);
+          return err;
+        }
+      xfree (pkbuf);
+      pkbuf = tmp;
+      pkbuflen = gcry_sexp_canon_len (pkbuf, 0, NULL, NULL);
+      assert (pkbuflen);
+
+      err = agent_write_private_key (grip, pkbuf, pkbuflen, 0);
+      if (err)
+        {
+          log_error (_("error writing key: %s\n"), gpg_strerror (err));
+          xfree (pkbuf);
+          gcry_sexp_release (s_pk);
+          xfree (serialno);
+          return err;
+        }
+    }
+
+  if (cardsn)
+    {
+      size_t snlen = strlen (serialno);
+
+      if (snlen == 32
+          && !memcmp (serialno, "D27600012401", 12)) /* OpenPGP card. */
+        *cardsn = xtryasprintf ("cardno:%.12s", serialno+16);
+      else /* Something is wrong: Print all. */
+        *cardsn = xtryasprintf ("cardno:%s", serialno);
+      if (!*cardsn)
+        {
+          err = gpg_error_from_errno (errno);
+          xfree (pkbuf);
+          gcry_sexp_release (s_pk);
+          xfree (serialno);
+          return err;
+        }
+    }
+
+  xfree (pkbuf);
+  xfree (serialno);
+  *r_pk = s_pk;
+  return 0;
 }
 
-\f
 
-static char *
-make_cstring (const char *data, size_t data_n)
-{
-  char *s;
+\f
 
-  s = xtrymalloc (data_n + 1);
-  if (s)
-    {
-      strncpy (s, data, data_n);
-      s[data_n] = 0;
-    }
+/*
 
-  return s;
-}
+  Request handler.  
 
-\f
+*/
 
-/* Request handler.  */
 
-static int
-ssh_handler_request_identities (ctrl_t ctrl, estream_t request, estream_t response)
+/* Handler for the "request_identities" command.  */
+static gpg_error_t
+ssh_handler_request_identities (ctrl_t ctrl,
+                                estream_t request, estream_t response)
 {
-  const char *key_type;
+  char *key_type;
   ssh_key_type_spec_t spec;
   struct dirent *dir_entry;
   char *key_directory;
@@ -1296,17 +1728,16 @@ ssh_handler_request_identities (ctrl_t ctrl, estream_t request, estream_t respon
   char *key_path;
   unsigned char *buffer;
   size_t buffer_n;
-  uint32_t key_counter;
+  u32 key_counter;
   estream_t key_blobs;
   gcry_sexp_t key_secret;
   gcry_sexp_t key_public;
   DIR *dir;
   gpg_error_t err;
   int ret;
-  int bad;
-
-  if (DBG_COMMAND)
-    log_debug ("[ssh-agent] request identities\n");
+  FILE *ctrl_fp = NULL;
+  char *cardsn;
+  gpg_error_t ret_err;
 
   /* Prepare buffer stream.  */
 
@@ -1318,7 +1749,6 @@ ssh_handler_request_identities (ctrl_t ctrl, estream_t request, estream_t respon
   key_counter = 0;
   buffer = NULL;
   dir = NULL;
-  bad = 0;
   err = 0;
 
   key_blobs = es_mopen (NULL, 0, 0, 1, NULL, NULL, "r+");
@@ -1354,65 +1784,96 @@ ssh_handler_request_identities (ctrl_t ctrl, estream_t request, estream_t respon
       goto out;
     }
 
-  /* Iterate over key files.  */
 
-  /* FIXME: make sure that buffer gets deallocated properly.  */
 
-  while (1)
+  /* First check whether a key is currently available in the card
+     reader - this should be allowed even without being listed in
+     sshcontrol. */
+
+  if (!card_key_available (ctrl, &key_public, &cardsn))
     {
-      dir_entry = readdir (dir);
-      if (dir_entry)
-       {
-         if ((strlen (dir_entry->d_name) == 44)
-             && (! strncmp (dir_entry->d_name + 40, ".key", 4)))
-           {
-             strncpy (key_path + key_directory_n + 1, dir_entry->d_name, 40);
-
-             /* Read file content.  */
-             err = es_read_file (key_path, &buffer, &buffer_n);
-             if (err)
-               break;
+      err = ssh_send_key_public (key_blobs, key_public, cardsn);
+      gcry_sexp_release (key_public);
+      key_public = NULL;
+      xfree (cardsn);
+      if (err)
+        goto out;
+      
+      key_counter++;
+    }
+
+
+  /* Then look at all the registered an allowed keys. */
+
+
+  /* Fixme: We should better iterate over the control file and check
+     whether the key file is there.  This is better in resepct to
+     performance if tehre are a lot of key sin our key storage. */
+  /* FIXME: make sure that buffer gets deallocated properly.  */
+  err = open_control_file (&ctrl_fp, 0);
+  if (err)
+    goto out;
+
+  while ( (dir_entry = readdir (dir)) )
+    {
+      if ((strlen (dir_entry->d_name) == 44)
+          && (! strncmp (dir_entry->d_name + 40, ".key", 4)))
+        {
+          char hexgrip[41];
+          int disabled;
+
+          /* We do only want to return keys listed in our control
+             file. */
+          strncpy (hexgrip, dir_entry->d_name, 40);
+          hexgrip[40] = 0;
+          if ( strlen (hexgrip) != 40 )
+            continue;
+          if (search_control_file (ctrl_fp, hexgrip, &disabled)
+              || disabled)
+            continue;
+
+          strncpy (key_path + key_directory_n + 1, dir_entry->d_name, 40);
+
+          /* Read file content.  */
+          err = file_to_buffer (key_path, &buffer, &buffer_n);
+          if (err)
+            goto out;
              
-             err = gcry_sexp_sscan (&key_secret, NULL, buffer, buffer_n);
-             if (err)
-               break;
+          err = gcry_sexp_sscan (&key_secret, NULL, buffer, buffer_n);
+          if (err)
+            goto out;
 
-             xfree (buffer);
-             buffer = NULL;
+          xfree (buffer);
+          buffer = NULL;
 
-             err = ssh_sexp_extract_key_type (key_secret, &key_type);
-             if (err)
-               break;
+          err = sexp_extract_identifier (key_secret, &key_type);
+          if (err)
+            goto out;
 
-             err = ssh_key_type_lookup (NULL, key_type, &spec);
-             if (err)
-               break;
+          err = ssh_key_type_lookup (NULL, key_type, &spec);
+          if (err)
+            goto out;
 
-             xfree ((void *) key_type);
-             key_type = NULL;
+          xfree (key_type);
+          key_type = NULL;
 
-             err = key_secret_to_public (&key_public, spec, key_secret);
-             if (err)
-               break;
+          err = key_secret_to_public (&key_public, spec, key_secret);
+          if (err)
+            goto out;
 
-             gcry_sexp_release (key_secret);
-             key_secret = NULL;
+          gcry_sexp_release (key_secret);
+          key_secret = NULL;
              
-             err = ssh_send_key_public (key_blobs, key_public);
-             if (err)
-               break;
+          err = ssh_send_key_public (key_blobs, key_public, NULL);
+          if (err)
+            goto out;
 
-             gcry_sexp_release (key_public);
-             key_public = NULL;
+          gcry_sexp_release (key_public);
+          key_public = NULL;
 
-             key_counter++;
-           }
-       }
-      else
-       break;
+          key_counter++;
+        }
     }
-  if (err)
-    goto out;
   
   ret = es_fseek (key_blobs, 0, SEEK_SET);
   if (ret)
@@ -1428,25 +1889,43 @@ ssh_handler_request_identities (ctrl_t ctrl, estream_t request, estream_t respon
   gcry_sexp_release (key_secret);
   gcry_sexp_release (key_public);
 
-  es_write_byte (response, SSH_RESPONSE_IDENTITIES_ANSWER);
-  if (! es_ferror (response))
-    es_write_uint32 (response, err ? 0 : key_counter);
-  if (! (err || es_ferror (response)))
-    es_copy (response, key_blobs);
+  if (! err)
+    {
+      ret_err = stream_write_byte (response, SSH_RESPONSE_IDENTITIES_ANSWER);
+      if (ret_err)
+       goto leave;
+      ret_err = stream_write_uint32 (response, key_counter);
+      if (ret_err)
+       goto leave;
+      ret_err = stream_copy (response, key_blobs);
+      if (ret_err)
+       goto leave;
+    }
+  else
+    {
+      ret_err = stream_write_byte (response, SSH_RESPONSE_FAILURE);
+      goto leave;
+    };
+
+ leave:
 
   if (key_blobs)
     es_fclose (key_blobs);
   if (dir)
     closedir (dir);
 
+  if (ctrl_fp)
+    fclose (ctrl_fp);
+
   free (key_directory);
   xfree (key_path);
   xfree (buffer);
-  xfree ((void *) key_type);           /* FIXME? */
+  xfree (key_type);
 
-  return bad;
+  return ret_err;
 }
 
+/*  */
 static gpg_error_t
 data_hash (unsigned char *data, size_t data_n,
           int md_algorithm, unsigned char *hash)
@@ -1456,11 +1935,11 @@ data_hash (unsigned char *data, size_t data_n,
   return 0;
 }
 
+
 static gpg_error_t
-data_sign (CTRL ctrl, ssh_signature_encoder_t sig_encoder,
+data_sign (ctrl_t ctrl, ssh_signature_encoder_t sig_encoder,
           unsigned char **sig, size_t *sig_n)
 {
-  char description[] = "Please provide the passphrase for key `%c':";
   gpg_error_t err;
   gcry_sexp_t signature_sexp;
   estream_t stream;
@@ -1469,7 +1948,7 @@ data_sign (CTRL ctrl, ssh_signature_encoder_t sig_encoder,
   gcry_mpi_t sig_value;
   unsigned char *sig_blob;
   size_t sig_blob_n;
-  const char *identifier;
+  char *identifier;
   const char *identifier_raw;
   size_t identifier_n;
   ssh_key_type_spec_t spec;
@@ -1489,7 +1968,11 @@ data_sign (CTRL ctrl, ssh_signature_encoder_t sig_encoder,
   sig_value = NULL;
   mpis = NULL;
 
-  err = agent_pksign_do (ctrl, description, &signature_sexp, 0);
+  ctrl->use_auth_call = 1;
+  err = agent_pksign_do (ctrl,
+                         _("Please enter the passphrase "
+                           "for the ssh key%0A  %c"), &signature_sexp, 0);
+  ctrl->use_auth_call = 0;
   if (err)
     goto out;
 
@@ -1525,7 +2008,7 @@ data_sign (CTRL ctrl, ssh_signature_encoder_t sig_encoder,
   if (err)
     goto out;
 
-  err = es_write_cstring (stream, spec.ssh_identifier);
+  err = stream_write_cstring (stream, spec.ssh_identifier);
   if (err)
     goto out;
 
@@ -1588,7 +2071,7 @@ data_sign (CTRL ctrl, ssh_signature_encoder_t sig_encoder,
       goto out;
     }    
 
-  err = es_read_data (stream, sig_blob, sig_blob_n);
+  err = stream_read_data (stream, sig_blob, sig_blob_n);
   if (err)
     goto out;
   
@@ -1606,12 +2089,12 @@ data_sign (CTRL ctrl, ssh_signature_encoder_t sig_encoder,
   gcry_sexp_release (signature_sexp);
   gcry_sexp_release (sublist);
   mpint_list_free (mpis);
-  xfree ((void *) identifier);
+  xfree (identifier);
 
   return err;
 }
 
-static int
+static gpg_error_t
 ssh_handler_sign_request (ctrl_t ctrl, estream_t request, estream_t response)
 {
   gcry_sexp_t key;
@@ -1620,56 +2103,40 @@ ssh_handler_sign_request (ctrl_t ctrl, estream_t request, estream_t response)
   unsigned int hash_n;
   unsigned char key_grip[20];
   unsigned char *key_blob;
-  uint32_t key_blob_size;
+  u32 key_blob_size;
   unsigned char *data;
   unsigned char *sig;
   size_t sig_n;
-  uint32_t data_size;
-  uint32_t flags;
-  const void *p;
+  u32 data_size;
+  u32 flags;
+  void *p;
   gpg_error_t err;
-  int bad;
+  gpg_error_t ret_err;
 
   key_blob = NULL;
   data = NULL;
   sig = NULL;
   key = NULL;
-  bad = 0;
-
-  if (DBG_COMMAND)
-    log_debug ("[ssh-agent] sign request\n");
 
   /* Receive key.  */
   
-  err = es_read_string (request, 0, &key_blob, &key_blob_size);
+  err = stream_read_string (request, 0, &key_blob, &key_blob_size);
   if (err)
-    {
-      bad = 1;
-      goto out;
-    }
+    goto out;
 
   err = ssh_read_key_public_from_blob (key_blob, key_blob_size, &key, &spec);
   if (err)
-    {
-      bad = 1;
-      goto out;
-    }
+    goto out;
 
   /* Receive data to sign.  */
-  err = es_read_string (request, 0, &data, &data_size);
+  err = stream_read_string (request, 0, &data, &data_size);
   if (err)
-    {
-      bad = 1;
-      goto out;
-    }
+    goto out;
 
   /* FIXME?  */
-  err = es_read_uint32 (request, &flags);
+  err = stream_read_uint32 (request, &flags);
   if (err)
-    {
-      bad = 1;
-      goto out;
-    }
+    goto out;
 
   /* Hash data.  */
   hash_n = gcry_md_get_algo_dlen (GCRY_MD_SHA1);
@@ -1703,63 +2170,34 @@ ssh_handler_sign_request (ctrl_t ctrl, estream_t request, estream_t response)
   
  out:
 
-  if (! bad)
+  /* Done.  */
+
+  if (! err)
     {
-      /* Done.  */
-      if (! err)
-       {
-         es_write_byte (response, SSH_RESPONSE_SIGN_RESPONSE);
-         if (! es_ferror (response))
-           es_write_string (response, sig, sig_n);
-       }
-      else
-       es_write_byte (response, SSH_RESPONSE_FAILURE);
+      ret_err = stream_write_byte (response, SSH_RESPONSE_SIGN_RESPONSE);
+      if (ret_err)
+       goto leave;
+      ret_err = stream_write_string (response, sig, sig_n);
+      if (ret_err)
+       goto leave;
+    }
+  else
+    {
+      ret_err = stream_write_byte (response, SSH_RESPONSE_FAILURE);
+      if (ret_err)
+       goto leave;
     }
   
+ leave:
+
   gcry_sexp_release (key);
   xfree (key_blob);
   xfree (data);
   xfree (sig);
 
-  return bad;
+  return ret_err;
 }
 
-static gpg_error_t
-get_passphrase (const char *description, size_t passphrase_n, char *passphrase)
-{
-  struct pin_entry_info_s *pi;
-  gpg_error_t err;
-
-  err = 0;
-  pi = gcry_calloc_secure (1, sizeof (*pi) + passphrase_n + 1);
-  if (! pi)
-    {
-      err = gpg_error (GPG_ERR_ENOMEM);
-      goto out;
-    }
-
-  pi->min_digits = 0;          /* We want a real passphrase.  */
-  pi->max_digits = 8;
-  pi->max_tries = 1;
-  pi->failed_tries = 0;
-  pi->check_cb = NULL;
-  pi->check_cb_arg = NULL;
-  pi->cb_errtext = NULL;
-  pi->max_length = 100;
-
-  err = agent_askpin (NULL, description, NULL, pi);
-  if (err)
-    goto out;
-
-  memcpy (passphrase, pi->pin, passphrase_n);
-  passphrase[passphrase_n] = 0;
-
- out:
-
-  xfree (pi);
-  
-  return err;
-}
 
 static gpg_error_t
 ssh_key_extract_comment (gcry_sexp_t key, char **comment)
@@ -1784,15 +2222,13 @@ ssh_key_extract_comment (gcry_sexp_t key, char **comment)
       goto out;
     }
 
-  comment_new = xtrymalloc (data_n + 1);
+  comment_new = make_cstring (data, data_n);
   if (! comment_new)
     {
       err = gpg_error_from_errno (errno);
       goto out;
     }
 
-  strncpy (comment_new, data, data_n);
-  comment_new[data_n] = 0;
   *comment = comment_new;
   err = 0;
 
@@ -1830,8 +2266,7 @@ ssh_key_to_buffer (gcry_sexp_t key, const char *passphrase,
 
   err = 0;
   buffer_new_n = gcry_sexp_sprint (key, GCRYSEXP_FMT_CANON, NULL, 0);
-  buffer_new = xtrymalloc (buffer_new_n);
-  /* FIXME: secmem? */
+  buffer_new = xtrymalloc_secure (buffer_new_n);
   if (! buffer_new)
     {
       err = gpg_error_from_errno (errno);
@@ -1850,80 +2285,100 @@ ssh_key_to_buffer (gcry_sexp_t key, const char *passphrase,
   return err;
 }
 
+
+
+/* Store the ssh KEY into our local key storage and protect him after
+   asking for a passphrase.  Cache that passphrase.  TTL is the
+   maximum caching time for that key.  If the key already exists in
+   our key storage, don't do anything.  When entering a new key also
+   add an entry to the sshcontrol file.  */
 static gpg_error_t
-ssh_identity_register (gcry_sexp_t key, int ttl)
+ssh_identity_register (ctrl_t ctrl, gcry_sexp_t key, int ttl)
 {
+  gpg_error_t err;
   unsigned char key_grip_raw[21];
-  unsigned char *buffer;
-  unsigned int buffer_n;
-  char passphrase[100];
-  size_t description_length;
-  char *description;
   char key_grip[41];
-  char *comment;
-  gpg_error_t err;
-  
-  int ret;
-
-  if (DBG_COMMAND)
-    log_debug ("[ssh-agent] registering identity `%s'\n", key_grip);
-
-  description = NULL;
-  comment = NULL;
-  buffer = NULL;
+  unsigned char *buffer = NULL;
+  unsigned int buffer_n;
+  char *description = NULL;
+  char *comment = NULL;
+  unsigned int i;
+  struct pin_entry_info_s *pi = NULL;
 
   err = ssh_key_grip (key, key_grip_raw);
   if (err)
     goto out;
 
-  key_grip_raw[sizeof (key_grip_raw) - 1] = 0;
-  ret = agent_key_available (key_grip_raw);
-  if (! ret)
-    goto out;
+  key_grip_raw[sizeof (key_grip_raw) - 1] = 0; /* FIXME:  Why?? */
+
+  /* Check whether the key is already in our key storage.  Don't do
+     anything then.  */
+  if ( !agent_key_available (key_grip_raw) )
+    goto out; /* Yes, key is available.  */
 
+  
   err = ssh_key_extract_comment (key, &comment);
   if (err)
     goto out;
 
-  description_length = 95 + (comment ? strlen (comment) : 0);
-  description = malloc (description_length);
-  if (! description)
+  if ( asprintf (&description,
+                 _("Please enter a passphrase to protect"
+                   " the received secret key%%0A"
+                   "   %s%%0A"
+                   "within gpg-agent's key storage"),
+                 comment ? comment : "?") < 0)
     {
-      err = gpg_err_code_from_errno (errno);
+      err = gpg_error_from_errno (errno);
       goto out;
     }
-  else
-    sprintf (description,
-            "Please provide the passphrase, which should be used "
-            "for protecting the received secret key `%s':",
-            comment ? comment : "");
 
-  err = get_passphrase (description, sizeof (passphrase), passphrase);
+
+  pi = gcry_calloc_secure (1, sizeof (*pi) + 100 + 1);
+  if (!pi)
+    {
+      err = gpg_error_from_errno (errno);
+      goto out;
+    }
+  pi->max_length = 100;
+  pi->max_tries = 1;
+  err = agent_askpin (ctrl, description, NULL, pi);
   if (err)
     goto out;
 
-  err = ssh_key_to_buffer (key, passphrase, &buffer, &buffer_n);
+  err = ssh_key_to_buffer (key, pi->pin, &buffer, &buffer_n);
   if (err)
     goto out;
 
+  /* Store this key to our key storage.  */
   err = agent_write_private_key (key_grip_raw, buffer, buffer_n, 0);
   if (err)
     goto out;
 
-  err = agent_put_cache (key_grip_raw, passphrase, ttl);
+  /* Cache this passphrase. */
+  for (i = 0; i < 20; i++)
+    sprintf (key_grip + 2 * i, "%02X", key_grip_raw[i]);
+
+  err = agent_put_cache (key_grip, pi->pin, ttl);
   if (err)
     goto out;
 
- out:
+  /* And add an entry to the sshcontrol file.  */
+  err = add_control_entry (ctrl, key_grip, ttl);
+
 
+ out:
+  if (pi && pi->max_length)
+    wipememory (pi->pin, pi->max_length);
+  xfree (pi);
   xfree (buffer);
   xfree (comment);
-  xfree (description);
-  /* FIXME: verify xfree vs free.  */
+  free (description); /* (asprintf allocated, thus regular free.)  */
 
   return err;
 }
 
+
+
 static gpg_error_t
 ssh_identity_drop (gcry_sexp_t key)
 {
@@ -1939,43 +2394,33 @@ ssh_identity_drop (gcry_sexp_t key)
   /* FIXME: What to do here - forgetting the passphrase or deleting
      the key from key cache?  */
 
-  if (DBG_COMMAND)
-    log_debug ("[ssh-agent] dropping identity `%s'\n", key_grip);
-
  out:
 
   return err;
 }
 
-static int
+static gpg_error_t
 ssh_handler_add_identity (ctrl_t ctrl, estream_t request, estream_t response)
 {
+  gpg_error_t ret_err;
   gpg_error_t err;
   gcry_sexp_t key;
-  byte_t b;
+  unsigned char b;
   int confirm;
-  int death;
-  int bad;
+  int ttl;
   
-  if (DBG_COMMAND)
-    log_debug ("[ssh-agent] add identity\n");
-
   confirm = 0;
-  death = 0;
   key = NULL;
-  bad = 0;
+  ttl = 0;
 
   /* FIXME?  */
   err = ssh_receive_key (request, &key, 1, 1, NULL);
   if (err)
-    {
-      bad = 1;
-      goto out;
-    }
+    goto out;
 
   while (1)
     {
-      err = es_read_byte (request, &b);
+      err = stream_read_byte (request, &b);
       if (gpg_err_code (err) == GPG_ERR_EOF)
        {
          err = 0;
@@ -1986,11 +2431,11 @@ ssh_handler_add_identity (ctrl_t ctrl, estream_t request, estream_t response)
        {
        case SSH_OPT_CONSTRAIN_LIFETIME:
          {
-           uint32_t n = 0;
+           u32 n = 0;
 
-           err = es_read_uint32 (request, &n);
+           err = stream_read_uint32 (request, &n);
            if (! err)
-             death = time (NULL) + n;
+             ttl = n;
            break;
          }
 
@@ -2008,54 +2453,44 @@ ssh_handler_add_identity (ctrl_t ctrl, estream_t request, estream_t response)
   if (err)
     goto out;
 
-  if (lifetime_default && (! death))
-    death = time (NULL) + lifetime_default;
-
   /* FIXME: are constraints used correctly?  */
 
-  err = ssh_identity_register (key, death);
+  err = ssh_identity_register (ctrl, key, ttl);
 
  out:
 
   gcry_sexp_release (key);
 
-  if (! bad)
-    es_write_byte (response, err ? SSH_RESPONSE_FAILURE : SSH_RESPONSE_SUCCESS);
+  if (! err)
+    ret_err = stream_write_byte (response, SSH_RESPONSE_SUCCESS);
+  else
+    ret_err = stream_write_byte (response, SSH_RESPONSE_FAILURE);
 
-  return bad;
+  return ret_err;
 }
 
-static int
-ssh_handler_remove_identity (ctrl_t ctrl, estream_t request, estream_t response)
+static gpg_error_t
+ssh_handler_remove_identity (ctrl_t ctrl, estream_t request,
+                             estream_t response)
 {
   unsigned char *key_blob;
-  uint32_t key_blob_size;
+  u32 key_blob_size;
   gcry_sexp_t key;
+  gpg_error_t ret_err;
   gpg_error_t err;
-  int bad;
 
   /* Receive key.  */
 
-  if (DBG_COMMAND)
-    log_debug ("[ssh-agent] remove identity\n");
-
   key_blob = NULL;
   key = NULL;
-  bad = 0;
   
-  err = es_read_string (request, 0, &key_blob, &key_blob_size);
+  err = stream_read_string (request, 0, &key_blob, &key_blob_size);
   if (err)
-    {
-      bad = 1;
-      goto out;
-    }
+    goto out;
 
   err = ssh_read_key_public_from_blob (key_blob, key_blob_size, &key, NULL);
   if (err)
-    {
-      bad = 1;
-      goto out;
-    }
+    goto out;
   
   err = ssh_identity_drop (key);
 
@@ -2064,10 +2499,12 @@ ssh_handler_remove_identity (ctrl_t ctrl, estream_t request, estream_t response)
   xfree (key_blob);
   gcry_sexp_release (key);
 
-  if (! bad)
-    es_write_byte (response, err ? SSH_RESPONSE_FAILURE : SSH_RESPONSE_SUCCESS);
+  if (! err)
+    ret_err = stream_write_byte (response, SSH_RESPONSE_SUCCESS);
+  else
+    ret_err = stream_write_byte (response, SSH_RESPONSE_FAILURE);
 
-  return bad;
+  return ret_err;
 }
 
 static gpg_error_t
@@ -2075,9 +2512,6 @@ ssh_identities_remove_all (void)
 {
   gpg_error_t err;
 
-  if (DBG_COMMAND)
-    log_debug ("[ssh-agent] remove all identities\n");
-
   err = 0;
 
   /* FIXME: shall we remove _all_ cache entries or only those
@@ -2086,15 +2520,21 @@ ssh_identities_remove_all (void)
   return err;
 }
 
-static int
-ssh_handler_remove_all_identities (ctrl_t ctrl, estream_t request, estream_t response)
+static gpg_error_t
+ssh_handler_remove_all_identities (ctrl_t ctrl, estream_t request,
+                                   estream_t response)
 {
+  gpg_error_t ret_err;
   gpg_error_t err;
   
   err = ssh_identities_remove_all ();
-  es_write_byte (response, err ? SSH_RESPONSE_FAILURE : SSH_RESPONSE_SUCCESS);
 
-  return 0;
+  if (! err)
+    ret_err = stream_write_byte (response, SSH_RESPONSE_SUCCESS);
+  else
+    ret_err = stream_write_byte (response, SSH_RESPONSE_FAILURE);
+
+  return ret_err;
 }
 
 static gpg_error_t
@@ -2102,9 +2542,8 @@ ssh_lock (void)
 {
   gpg_error_t err;
 
-  if (DBG_COMMAND)
-    log_debug ("[ssh-agent] lock\n");
-
+  /* FIXME */
+  log_error ("ssh-agent's lock command is not implemented\n");
   err = 0;
 
   return err;
@@ -2115,213 +2554,289 @@ ssh_unlock (void)
 {
   gpg_error_t err;
 
-  if (DBG_COMMAND)
-    log_debug ("[ssh-agent] unlock\n");
-
+  log_error ("ssh-agent's unlock command is not implemented\n");
   err = 0;
 
   return err;
 }
 
-static int
+static gpg_error_t
 ssh_handler_lock (ctrl_t ctrl, estream_t request, estream_t response)
 {
+  gpg_error_t ret_err;
   gpg_error_t err;
   
   err = ssh_lock ();
-  es_write_byte (response, err ? SSH_RESPONSE_FAILURE : SSH_RESPONSE_SUCCESS);
 
-  return 0;
+  if (! err)
+    ret_err = stream_write_byte (response, SSH_RESPONSE_SUCCESS);
+  else
+    ret_err = stream_write_byte (response, SSH_RESPONSE_FAILURE);
+
+  return ret_err;
 }
 
-static int
+static gpg_error_t
 ssh_handler_unlock (ctrl_t ctrl, estream_t request, estream_t response)
 {
+  gpg_error_t ret_err;
   gpg_error_t err;
   
-  err =  ssh_unlock ();
-  es_write_byte (response, err ? SSH_RESPONSE_FAILURE : SSH_RESPONSE_SUCCESS);
+  err = ssh_unlock ();
 
-  return 0;
+  if (! err)
+    ret_err = stream_write_byte (response, SSH_RESPONSE_SUCCESS);
+  else
+    ret_err = stream_write_byte (response, SSH_RESPONSE_FAILURE);
+
+  return ret_err;
 }
 
 \f
 
-/* Associating request types with the corresponding request
-   handlers.  */
+static ssh_request_spec_t *
+request_spec_lookup (int type)
+{
+  ssh_request_spec_t *spec;
+  unsigned int i;
 
-static ssh_request_spec_t request_specs[] =
-  {
-    { SSH_REQUEST_REQUEST_IDENTITIES,    ssh_handler_request_identities },
-    { SSH_REQUEST_SIGN_REQUEST,          ssh_handler_sign_request },
-    { SSH_REQUEST_ADD_IDENTITY,          ssh_handler_add_identity },
-    { SSH_REQUEST_ADD_ID_CONSTRAINED,    ssh_handler_add_identity },
-    { SSH_REQUEST_REMOVE_IDENTITY,       ssh_handler_remove_identity },
-    { SSH_REQUEST_REMOVE_ALL_IDENTITIES, ssh_handler_remove_all_identities },
-    { SSH_REQUEST_LOCK,                  ssh_handler_lock },
-    { SSH_REQUEST_UNLOCK,                ssh_handler_unlock },
-  };
+  for (i = 0; i < DIM (request_specs); i++)
+    if (request_specs[i].type == type)
+      break;
+  if (i == DIM (request_specs))
+    {
+      log_info ("ssh request %u is not supported\n", type);
+      spec = NULL;
+    }
+  else
+    spec = request_specs + i;
 
-\f
+  return spec;
+}
 
-static gpg_error_t
-ssh_request_process (ctrl_t ctrl, estream_t request, estream_t response)
+static int
+ssh_request_process (ctrl_t ctrl, estream_t stream_sock)
 {
-  byte_t request_type;
+  ssh_request_spec_t *spec;
+  estream_t response;
+  estream_t request;
+  unsigned char request_type;
   gpg_error_t err;
-  unsigned int i;
-  int bad;
+  int send_err;
+  int ret;
+  unsigned char *request_data;
+  u32 request_data_size;
+  u32 response_size;
+
+  request_data = NULL;
+  response = NULL;
+  request = NULL;
+  send_err = 0;
+
+  /* Create memory streams for request/response data.  The entire
+     request will be stored in secure memory, since it might contain
+     secret key material.  The response does not have to be stored in
+     secure memory, since we never give out secret keys. 
 
-  err = es_read_byte (request, &request_type);
+     FIXME: This is a pretty good DoS.  We only have a limited amount
+     of secure memory, we can't trhow hin everything we get from a
+     client -wk */
+      
+  /* Retrieve request.  */
+  err = stream_read_string (stream_sock, 1, &request_data, &request_data_size);
   if (err)
     goto out;
 
-  if (DBG_COMMAND)
-    log_debug ("[ssh-agent] request: %u\n", request_type);
+  if (opt.verbose > 1)
+    log_info ("received ssh request of length %u\n",
+              (unsigned int)request_data_size);
 
-  for (i = 0; i < DIM (request_specs); i++)
-    if (request_specs[i].type == request_type)
-      break;
-  if (i == DIM (request_specs))
+  if (! request_data_size)
     {
-      err = es_write_byte (response, SSH_RESPONSE_FAILURE);
+      send_err = 1;
       goto out;
+      /* Broken request; FIXME.  */
     }
 
-  
-  bad = (*request_specs[i].handler) (ctrl, request, response);
-  if (bad)
-    err = GPG_ERR_PROTOCOL_VIOLATION;
+  request_type = request_data[0];
+  spec = request_spec_lookup (request_type);
+  if (! spec)
+    {
+      send_err = 1;
+      goto out;
+      /* Unknown request; FIXME.  */
+    }
+
+  if (spec->secret_input)
+    request = es_mopen (NULL, 0, 0, 1, realloc_secure, gcry_free, "r+");
+  else
+    request = es_mopen (NULL, 0, 0, 1, gcry_realloc, gcry_free, "r+");
+  if (! request)
+    {
+      err = gpg_error_from_errno (errno);
+      goto out;
+    }
+  ret = es_setvbuf (request, NULL, _IONBF, 0);
+  if (ret)
+    {
+      err = gpg_error_from_errno (errno);
+      goto out;
+    }
+  err = stream_write_data (request, request_data + 1, request_data_size - 1);
+  if (err)
+    goto out;
+  es_rewind (request);
+
+  response = es_mopen (NULL, 0, 0, 1, NULL, NULL, "r+");
+  if (! response)
+    {
+      err = gpg_error_from_errno (errno);
+      goto out;
+    }
+
+  if (opt.verbose)
+    log_info ("ssh request handler for %s (%u) started\n",
+              spec->identifier, spec->type);
+
+  err = (*spec->handler) (ctrl, request, response);
+
+  if (opt.verbose)
+    {
+      if (err)
+        log_info ("ssh request handler for %s (%u) failed: %s\n",
+                  spec->identifier, spec->type, gpg_strerror (err));
+      else
+        log_info ("ssh request handler for %s (%u) ready\n",
+                  spec->identifier, spec->type);
+    }
+
+  if (err)
+    {
+      send_err = 1;
+      goto out;
+    }
+
+  response_size = es_ftell (response);
+  if (opt.verbose > 1)
+    log_info ("sending ssh response of length %u\n",
+              (unsigned int)response_size);
+
+  err = es_fseek (response, 0, SEEK_SET);
+  if (err)
+    {
+      send_err = 1;
+      goto out;
+    }
+
+  err = stream_write_uint32 (stream_sock, response_size);
+  if (err)
+    {
+      send_err = 1;
+      goto out;
+    }
+
+  err = stream_copy (stream_sock, response);
+  if (err)
+    goto out;
+
+  err = es_fflush (stream_sock);
+  if (err)
+    goto out;
 
  out:
 
-  return err;
+  if (err && es_feof (stream_sock))
+    log_error ("error occured while processing request: %s\n",
+              gpg_strerror (err));
+
+  if (send_err)
+    {
+      if (opt.verbose > 1)
+        log_info ("sending ssh error response\n");
+      err = stream_write_uint32 (stream_sock, 1);
+      if (err)
+       goto leave;
+      err = stream_write_byte (stream_sock, SSH_RESPONSE_FAILURE);
+      if (err)
+       goto leave;
+    }
+
+ leave:
+
+  if (request)
+    es_fclose (request);
+  if (response)
+    es_fclose (response);
+  xfree (request_data);                /* FIXME?  */
+
+  return !!err;
 }
 
 void
 start_command_handler_ssh (int sock_client)
 {
   struct server_control_s ctrl;
-  gpg_error_t err;
-  estream_t stream_response;
-  estream_t stream_request;
   estream_t stream_sock;
-  unsigned char *request;
-  uint32_t request_size;
-  size_t size;
+  gpg_error_t err;
+  int bad;
   int ret;
 
   /* Setup control structure.  */
 
-  if (DBG_COMMAND)
-    log_debug ("[ssh-agent] Starting command handler\n");
-
   memset (&ctrl, 0, sizeof (ctrl));
+  agent_init_default_ctrl (&ctrl);
   ctrl.connection_fd = sock_client;
 
-  stream_response = NULL;
-  stream_request = NULL;
-  stream_sock = NULL;
-  request = NULL;
-
+  /* Because the ssh protocol does not send us information about the
+     the current TTY setting, we resort here to use those from startup
+     or those explictly set.  */
+  if (!ctrl.display && opt.startup_display)
+    ctrl.display = strdup (opt.startup_display);
+  if (!ctrl.ttyname && opt.startup_ttyname)
+    ctrl.ttyname = strdup (opt.startup_ttyname);
+  if (!ctrl.ttytype && opt.startup_ttytype)
+    ctrl.ttytype = strdup (opt.startup_ttytype);
+  if (!ctrl.lc_ctype && opt.startup_lc_ctype)
+    ctrl.lc_ctype = strdup (opt.startup_lc_ctype);
+  if (!ctrl.lc_messages && opt.startup_lc_messages)
+    ctrl.lc_messages = strdup (opt.startup_lc_messages);
+
+
+  /* Create stream from socket.  */
   stream_sock = es_fdopen (sock_client, "r+");
-  if (! stream_sock)
+  if (!stream_sock)
     {
       err = gpg_error_from_errno (errno);
+      log_error (_("failed to create stream from socket: %s\n"),
+                gpg_strerror (err));
       goto out;
     }
+  /* We have to disable the estream buffering, because the estream
+     core doesn't know about secure memory.  */
   ret = es_setvbuf (stream_sock, NULL, _IONBF, 0);
   if (ret)
     {
       err = gpg_error_from_errno (errno);
+      log_error (_("failed to disable buffering "
+                   "on socket stream: %s\n"), gpg_strerror (err));
       goto out;
     }
 
   while (1)
     {
-      /* Create memory streams for request/response data.  The entire
-        request will be stored in secure memory, since it might
-        contain secret key material.  The response does not have to
-        be stored in secure memory, since we never give out secret
-        keys.  FIXME: wrong place.  */
-      
-      /* Retrieve request.  */
-      err = es_read_string (stream_sock, 1, &request, &request_size);
-      if (err)
-       break;
-
-      if (DBG_COMMAND)
-       log_debug ("[ssh-agent] Received request of length: %u\n",
-                  request_size);
-
-      stream_request = es_mopen (NULL, 0, 0, 1,
-                                realloc_secure, gcry_free, "r+");
-      if (! stream_request)
-       {
-         err = gpg_error_from_errno (errno);
-         break;
-       }
-      ret = es_setvbuf (stream_request, NULL, _IONBF, 0);
-      if (ret)
-       {
-         err = gpg_error_from_errno (errno);
-         break;
-       }
-      err = es_write_data (stream_request, request, request_size);
-      if (err)
-       break;
-      es_rewind (stream_request);
-
-      stream_response = es_mopen (NULL, 0, 0, 1, NULL, NULL, "r+");
-      if (! stream_response)
-       {
-         err = gpg_error_from_errno (errno);
-         break;
-       }
-
-      /* Process request.  */
-      err = ssh_request_process (&ctrl, stream_request, stream_response);
-      if (err)
-       break;
-      /* Figure out size of response data.  */
-      size = es_ftell (stream_response);
-      err = es_fseek (stream_response, 0, SEEK_SET);
-      if (err)
+      bad = ssh_request_process (&ctrl, stream_sock);
+      if (bad)
        break;
-
-      /* Write response data to socket stream.  */
-      err = es_write_uint32 (stream_sock, size);
-      if (err)
-       break;
-      err = es_copy (stream_sock, stream_response);
-      if (err)
-       break;
-      
-      err = es_fflush (stream_sock);
-      if (err)
-       break;
-
-      es_fclose (stream_request);
-      stream_request = NULL;
-      es_fclose (stream_response);
-      stream_response = NULL;
-      xfree (request);
-      request = NULL;
     };
 
  out:
 
-  /* FIXME: logging.  */
-
   if (stream_sock)
     es_fclose (stream_sock);
-  if (stream_request)
-    es_fclose (stream_request);
-  if (stream_response)
-    es_fclose (stream_response);
-  xfree (request);             /* FIXME?  */
-
-  if (DBG_COMMAND)
-    log_debug ("[ssh-agent] Leaving ssh command handler: %s\n", gpg_strerror (err));
+
+  free (ctrl.display);
+  free (ctrl.ttyname);
+  free (ctrl.ttytype);
+  free (ctrl.lc_ctype);
+  free (ctrl.lc_messages);
 }