* gpgsm.c: New command --keydb-clear-some-cert-flags.
[gnupg.git] / sm / call-agent.c
index 16cc46f..2e8c754 100644 (file)
@@ -1,5 +1,5 @@
 /* call-agent.c - divert operations to the agent
- *     Copyright (C) 2001 Free Software Foundation, Inc.
+ *     Copyright (C) 2001, 2002, 2003 Free Software Foundation, Inc.
  *
  * This file is part of GnuPG.
  *
 #include <unistd.h> 
 #include <time.h>
 #include <assert.h>
-
-#include <gcrypt.h>
+#ifdef HAVE_LOCALE_H
+#include <locale.h>
+#endif
 
 #include "gpgsm.h"
-#include "../assuan/assuan.h"
+#include <gcrypt.h>
+#include <assuan.h>
 #include "i18n.h"
+#include "asshelp.h"
+#include "keydb.h" /* fixme: Move this to import.c */
+#include "../common/membuf.h"
 
-#ifdef _POSIX_OPEN_MAX
-#define MAX_OPEN_FDS _POSIX_OPEN_MAX
-#else
-#define MAX_OPEN_FDS 20
-#endif
-
-#define LINELENGTH 1002 /* 1000 + [CR,]LF */
 
-#define xtoi_1(p)   (*(p) <= '9'? (*(p)- '0'): \
-                     *(p) <= 'F'? (*(p)-'A'+10):(*(p)-'a'+10))
-#define xtoi_2(p)   ((xtoi_1(p) * 16) + xtoi_1((p)+1))
+static ASSUAN_CONTEXT agent_ctx = NULL;
+static int force_pipe_server = 0;
 
+struct cipher_parm_s {
+  ASSUAN_CONTEXT ctx;
+  const char *ciphertext;
+  size_t ciphertextlen;
+};
 
-static pid_t agent_pid = -1;
-/* fixme: replace this code by calling assuna functions */
-static int inbound_fd = -1;
-static int outbound_fd = -1;
-static struct {
-  int eof;
-  char line[LINELENGTH];
-  int linelen;  /* w/o CR, LF - might not be the same as
-                   strlen(line) due to embedded nuls. However a nul
-                   is always written at this pos */
-  struct {
-    char line[LINELENGTH];
-    int linelen ;
-  } attic;
-} inbound;
-
+struct genkey_parm_s {
+  ASSUAN_CONTEXT ctx;
+  const char *sexp;
+  size_t sexplen;
+};
 
-struct membuf {
-  size_t len;
-  size_t size;
-  char *buf;
-  int out_of_core;
+struct learn_parm_s {
+  int error;
+  ASSUAN_CONTEXT ctx;
+  membuf_t *data;
 };
 
 
 \f
-/* A simple implemnation of a dynamic buffer.  Use init_membuf() to
-   create a buffer, put_membuf to append bytes and get_membuf to
-   release and return the buffer.  Allocation errors are detected but
-   only returned at the final get_membuf(), this helps not to clutter
-   the code with out of core checks.  */
-
-static void
-init_membuf (struct membuf *mb, int initiallen)
+/* Try to connect to the agent via socket or fork it off and work by
+   pipes.  Handle the server's initial greeting */
+static int
+start_agent (ctrl_t ctrl)
 {
-  mb->len = 0;
-  mb->size = initiallen;
-  mb->out_of_core = 0;
-  mb->buf = xtrymalloc (initiallen);
-  if (!mb->buf)
-      mb->out_of_core = 1;
-}
+  int rc = 0;
+  char *infostr, *p;
+  assuan_context_t ctx;
 
-static void
-put_membuf (struct membuf *mb, const void *buf, size_t len)
-{
-  if (mb->out_of_core)
-    return;
+  if (agent_ctx)
+    return 0; /* fixme: We need a context for each thread or serialize
+                 the access to the agent (which is suitable given that
+                 the agent is not MT. */
 
-  if (mb->len + len >= mb->size)
+  infostr = force_pipe_server? NULL : getenv ("GPG_AGENT_INFO");
+  if (!infostr || !*infostr)
     {
-      char *p;
+      const char *pgmname;
+      const char *argv[3];
+      int no_close_list[3];
+      int i;
+
+      if (opt.verbose)
+        log_info (_("no running gpg-agent - starting one\n"));
       
-      mb->size += len + 1024;
-      p = xtryrealloc (mb->buf, mb->size);
-      if (!p)
+      gpgsm_status (ctrl, STATUS_PROGRESS, "starting_agent ? 0 0");
+
+      if (fflush (NULL))
         {
-          mb->out_of_core = 1;
-          return;
+          gpg_error_t tmperr = gpg_error (gpg_err_code_from_errno (errno));
+          log_error ("error flushing pending output: %s\n", strerror (errno));
+          return tmperr;
         }
-      mb->buf = p;
+
+      if (!opt.agent_program || !*opt.agent_program)
+        opt.agent_program = GNUPG_DEFAULT_AGENT;
+      if ( !(pgmname = strrchr (opt.agent_program, '/')))
+        pgmname = opt.agent_program;
+      else
+        pgmname++;
+
+      argv[0] = pgmname;
+      argv[1] = "--server";
+      argv[2] = NULL;
+
+      i=0;
+      if (log_get_fd () != -1)
+        no_close_list[i++] = log_get_fd ();
+      no_close_list[i++] = fileno (stderr);
+      no_close_list[i] = -1;
+
+      /* connect to the agent and perform initial handshaking */
+      rc = assuan_pipe_connect (&ctx, opt.agent_program, (char**)argv,
+                                no_close_list);
     }
-  memcpy (mb->buf + mb->len, buf, len);
-  mb->len += len;
-}
+  else
+    {
+      int prot;
+      int pid;
 
-static void *
-get_membuf (struct membuf *mb, size_t *len)
-{
-  char *p;
+      infostr = xstrdup (infostr);
+      if ( !(p = strchr (infostr, ':')) || p == infostr)
+        {
+          log_error (_("malformed GPG_AGENT_INFO environment variable\n"));
+          xfree (infostr);
+          force_pipe_server = 1;
+          return start_agent (ctrl);
+        }
+      *p++ = 0;
+      pid = atoi (p);
+      while (*p && *p != ':')
+        p++;
+      prot = *p? atoi (p+1) : 0;
+      if (prot != 1)
+        {
+          log_error (_("gpg-agent protocol version %d is not supported\n"),
+                     prot);
+          xfree (infostr);
+          force_pipe_server = 1;
+          return start_agent (ctrl);
+        }
+
+      rc = assuan_socket_connect (&ctx, infostr, pid);
+      xfree (infostr);
+      if (rc == ASSUAN_Connect_Failed)
+        {
+          log_error (_("can't connect to the agent - trying fall back\n"));
+          force_pipe_server = 1;
+          return start_agent (ctrl);
+        }
+    }
 
-  if (mb->out_of_core)
+  if (rc)
     {
-      xfree (mb->buf);
-      mb->buf = NULL;
-      return NULL;
+      log_error ("can't connect to the agent: %s\n", assuan_strerror (rc));
+      return gpg_error (GPG_ERR_NO_AGENT);
     }
+  agent_ctx = ctx;
+
+  if (DBG_ASSUAN)
+    log_debug ("connection to agent established\n");
+
+  rc = assuan_transact (agent_ctx, "RESET", NULL, NULL, NULL, NULL, NULL, NULL);
+  if (rc)
+    return map_assuan_err (rc);
+
+  return send_pinentry_environment (agent_ctx,
+                                    opt.display, opt.ttyname, opt.ttytype,
+                                    opt.lc_ctype, opt.lc_messages);
+}
 
-  p = mb->buf;
-  *len = mb->len;
-  mb->buf = NULL;
-  mb->out_of_core = 1; /* don't allow a reuse */
-  return p;
+
+static AssuanError
+membuf_data_cb (void *opaque, const void *buffer, size_t length)
+{
+  membuf_t *data = opaque;
+
+  if (buffer)
+    put_membuf (data, buffer, length);
+  return 0;
 }
+  
 
 
 \f
-static int
-writen (int fd, const void *buf, size_t nbytes)
+/* Call the agent to do a sign operation using the key identified by
+   the hex string KEYGRIP. */
+int
+gpgsm_agent_pksign (ctrl_t ctrl, const char *keygrip, const char *desc,
+                    unsigned char *digest, size_t digestlen, int digestalgo,
+                    char **r_buf, size_t *r_buflen )
 {
-  size_t nleft = nbytes;
-  int nwritten;
+  int rc, i;
+  char *p, line[ASSUAN_LINELENGTH];
+  membuf_t data;
+  size_t len;
+
+  *r_buf = NULL;
+  rc = start_agent (ctrl);
+  if (rc)
+    return rc;
+
+  if (digestlen*2 + 50 > DIM(line))
+    return gpg_error (GPG_ERR_GENERAL);
+
+  rc = assuan_transact (agent_ctx, "RESET", NULL, NULL, NULL, NULL, NULL, NULL);
+  if (rc)
+    return map_assuan_err (rc);
+
+  snprintf (line, DIM(line)-1, "SIGKEY %s", keygrip);
+  line[DIM(line)-1] = 0;
+  rc = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
+  if (rc)
+    return map_assuan_err (rc);
 
-  while (nleft > 0)
+  if (desc)
     {
-      nwritten = write (fd, buf, nleft);
-      if (nwritten < 0)
-        {
-          if (errno == EINTR)
-            nwritten = 0;
-          else 
-            {
-              log_error ("write() failed: %s\n", strerror (errno));
-              return seterr (Write_Error);
-            }
-        }
-      nleft -= nwritten;
-      buf = (const char*)buf + nwritten;
+      snprintf (line, DIM(line)-1, "SETKEYDESC %s", desc);
+      line[DIM(line)-1] = 0;
+      rc = assuan_transact (agent_ctx, line,
+                            NULL, NULL, NULL, NULL, NULL, NULL);
+      if (rc)
+        return map_assuan_err (rc);
     }
-  
-  return 0;
+
+  sprintf (line, "SETHASH %d ", digestalgo);
+  p = line + strlen (line);
+  for (i=0; i < digestlen ; i++, p += 2 )
+    sprintf (p, "%02X", digest[i]);
+  rc = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
+  if (rc)
+    return map_assuan_err (rc);
+
+  init_membuf (&data, 1024);
+  rc = assuan_transact (agent_ctx, "PKSIGN",
+                        membuf_data_cb, &data, NULL, NULL, NULL, NULL);
+  if (rc)
+    {
+      xfree (get_membuf (&data, &len));
+      return map_assuan_err (rc);
+    }
+  *r_buf = get_membuf (&data, r_buflen);
+
+  if (!gcry_sexp_canon_len (*r_buf, *r_buflen, NULL, NULL))
+    {
+      xfree (*r_buf); *r_buf = NULL;
+      return gpg_error (GPG_ERR_INV_VALUE);
+    }
+
+  return *r_buf? 0 : OUT_OF_CORE (errno);
 }
 
 
 
-/* read an entire line */
-static int
-readline (int fd, char *buf, size_t buflen, int *r_nread, int *eof)
+\f
+/* Handle a CIPHERTEXT inquiry.  Note, we only send the data,
+   assuan_transact talkes care of flushing and writing the end */
+static AssuanError
+inq_ciphertext_cb (void *opaque, const char *keyword)
 {
-  size_t nleft = buflen;
-  int n;
-  char *p;
+  struct cipher_parm_s *parm = opaque; 
+  AssuanError rc;
 
-  *eof = 0;
-  *r_nread = 0;
-  while (nleft > 0)
-    {
-      do 
-        n = read (fd, buf, nleft);
-      while (n < 0 && errno == EINTR);
-      if (n < 0)
-        {
-          log_error ("read() error: %s\n", strerror (errno) );
-          return seterr (Read_Error);
-        }
-        
-      if (!n)
-        {
-          *eof = 1;
-          break; /* allow incomplete lines */
-        }
-      p = buf;
-      nleft -= n;
-      buf += n;
-      *r_nread += n;
-      
-      for (; n && *p != '\n'; n--, p++)
-        ;
-      if (n)
-        break; /* at least one full line available - that's enough for now */
-    }
-  
-  return 0;
+  assuan_begin_confidential (parm->ctx);
+  rc = assuan_send_data (parm->ctx, parm->ciphertext, parm->ciphertextlen);
+  assuan_end_confidential (parm->ctx);
+  return rc; 
 }
 
 
-static int
-read_from_agent (int *okay)
+/* Call the agent to do a decrypt operation using the key identified by
+   the hex string KEYGRIP. */
+int
+gpgsm_agent_pkdecrypt (ctrl_t ctrl, const char *keygrip, const char *desc,
+                       ksba_const_sexp_t ciphertext, 
+                       char **r_buf, size_t *r_buflen )
 {
-  char *line = inbound.line;
-  int n, nread;
   int rc;
+  char line[ASSUAN_LINELENGTH];
+  membuf_t data;
+  struct cipher_parm_s cipher_parm;
+  size_t n, len;
+  char *buf, *endp;
+  size_t ciphertextlen;
+  
+  if (!keygrip || strlen(keygrip) != 40 || !ciphertext || !r_buf || !r_buflen)
+    return gpg_error (GPG_ERR_INV_VALUE);
+  *r_buf = NULL;
 
-  *okay = 0;
- restart:  
-  if (inbound.eof)
-    return -1;
+  ciphertextlen = gcry_sexp_canon_len (ciphertext, 0, NULL, NULL);
+  if (!ciphertextlen)
+    return gpg_error (GPG_ERR_INV_VALUE);
 
-  if (inbound.attic.linelen)
-    {
-      memcpy (line, inbound.attic.line, inbound.attic.linelen);
-      nread = inbound.attic.linelen;
-      inbound.attic.linelen = 0;
-      for (n=0; n < nread && line[n] != '\n'; n++)
-        ;
-      if (n < nread)
-        rc = 0; /* found another line in the attic */
-      else
-        { /* read the rest */
-          n = nread;
-          assert (n < LINELENGTH);
-          rc = readline (inbound_fd, line + n, LINELENGTH - n,
-                         &nread, &inbound.eof);
-        }
-    }
-  else
-    rc = readline (inbound_fd, line, LINELENGTH,
-                   &nread, &inbound.eof);
+  rc = start_agent (ctrl);
+  if (rc)
+    return rc;
+
+  rc = assuan_transact (agent_ctx, "RESET", NULL, NULL, NULL, NULL, NULL, NULL);
+  if (rc)
+    return map_assuan_err (rc);
+
+  assert ( DIM(line) >= 50 );
+  snprintf (line, DIM(line)-1, "SETKEY %s", keygrip);
+  line[DIM(line)-1] = 0;
+  rc = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
   if (rc)
-    return seterr(Read_Error);
-  if (!nread)
+    return map_assuan_err (rc);
+
+  if (desc)
     {
-      assert (inbound.eof);
-      return -1; /* eof */ 
+      snprintf (line, DIM(line)-1, "SETKEYDESC %s", desc);
+      line[DIM(line)-1] = 0;
+      rc = assuan_transact (agent_ctx, line,
+                            NULL, NULL, NULL, NULL, NULL, NULL);
+      if (rc)
+        return map_assuan_err (rc);
     }
 
-  for (n=0; n < nread; n++)
+  init_membuf (&data, 1024);
+  cipher_parm.ctx = agent_ctx;
+  cipher_parm.ciphertext = ciphertext;
+  cipher_parm.ciphertextlen = ciphertextlen;
+  rc = assuan_transact (agent_ctx, "PKDECRYPT",
+                        membuf_data_cb, &data,
+                        inq_ciphertext_cb, &cipher_parm, NULL, NULL);
+  if (rc)
     {
-      if (line[n] == '\n')
-        {
-          if (n+1 < nread)
-            {
-              n++;
-              /* we have to copy the rest because the handlers are
-                 allowed to modify the passed buffer */
-              memcpy (inbound.attic.line, line+n, nread-n);
-              inbound.attic.linelen = nread-n;
-              n--;
-            }
-          if (n && line[n-1] == '\r')
-            n--;
-          line[n] = 0;
-          inbound.linelen = n;
-          if (n && *line == '#')
-            goto restart;
-
-          rc = 0;
-          if (n >= 1
-              && line[0] == 'D' && line[1] == ' ')
-            *okay = 2; /* data line */
-          else if (n >= 2
-              && line[0] == 'O' && line[1] == 'K'
-              && (line[2] == '\0' || line[2] == ' '))
-            *okay = 1;
-          else if (n >= 3
-                   && line[0] == 'E' && line[1] == 'R' && line[2] == 'R'
-                   && (line[3] == '\0' || line[3] == ' '))
-            *okay = 0;
-          else
-            rc = seterr (Invalid_Response);
-          return rc;
-        }
+      xfree (get_membuf (&data, &len));
+      return map_assuan_err (rc);
     }
 
-  *line = 0;
-  inbound.linelen = 0;
-  return inbound.eof? seterr (Incomplete_Line):seterr (Invalid_Response);
+  put_membuf (&data, "", 1); /* make sure it is 0 terminated */
+  buf = get_membuf (&data, &len);
+  if (!buf)
+    return gpg_error (GPG_ERR_ENOMEM);
+  /* FIXME: We would better a return a full S-exp and not just a part */
+  assert (len);
+  len--; /* remove the terminating 0 */
+  n = strtoul (buf, &endp, 10);
+  if (!n || *endp != ':')
+    return gpg_error (GPG_ERR_INV_SEXP);
+  endp++;
+  if (endp-buf+n > len)
+    return gpg_error (GPG_ERR_INV_SEXP); /* oops len does not
+                                           match internal len*/
+  memmove (buf, endp, n);
+  *r_buflen = n;
+  *r_buf = buf;
+  return 0;
 }
 
 
 
 
 \f
-/* Try to connect to the agent via socket or fork it off and work by
-   pipes.  Handle the server's initial greeting */
-static int
-start_agent (void)
+/* Handle a KEYPARMS inquiry.  Note, we only send the data,
+   assuan_transact takes care of flushing and writing the end */
+static AssuanError
+inq_genkey_parms (void *opaque, const char *keyword)
+{
+  struct genkey_parm_s *parm = opaque; 
+  AssuanError rc;
+
+  rc = assuan_send_data (parm->ctx, parm->sexp, parm->sexplen);
+  return rc; 
+}
+
+
+\f
+/* Call the agent to generate a newkey */
+int
+gpgsm_agent_genkey (ctrl_t ctrl,
+                    ksba_const_sexp_t keyparms, ksba_sexp_t *r_pubkey)
 {
   int rc;
-  char *infostr, *p;
-  int okay;
+  struct genkey_parm_s gk_parm;
+  membuf_t data;
+  size_t len;
+  char *buf;
 
-  if (agent_pid != -1)
-    return 0;
+  *r_pubkey = NULL;
+  rc = start_agent (ctrl);
+  if (rc)
+    return rc;
+
+  rc = assuan_transact (agent_ctx, "RESET", NULL, NULL, NULL, NULL, NULL, NULL);
+  if (rc)
+    return map_assuan_err (rc);
 
-  infostr = getenv ("GPG_AGENT_INFO");
-  if (!infostr)
+  init_membuf (&data, 1024);
+  gk_parm.ctx = agent_ctx;
+  gk_parm.sexp = keyparms;
+  gk_parm.sexplen = gcry_sexp_canon_len (keyparms, 0, NULL, NULL);
+  if (!gk_parm.sexplen)
+    return gpg_error (GPG_ERR_INV_VALUE);
+  rc = assuan_transact (agent_ctx, "GENKEY",
+                        membuf_data_cb, &data, 
+                        inq_genkey_parms, &gk_parm, NULL, NULL);
+  if (rc)
+    {
+      xfree (get_membuf (&data, &len));
+      return map_assuan_err (rc);
+    }
+  buf = get_membuf (&data, &len);
+  if (!buf)
+    return gpg_error (GPG_ERR_ENOMEM);
+  if (!gcry_sexp_canon_len (buf, len, NULL, NULL))
     {
-      pid_t pid;
-      int inpipe[2], outpipe[2];
+      xfree (buf);
+      return gpg_error (GPG_ERR_INV_SEXP);
+    }
+  *r_pubkey = buf;
+  return 0;
+}
 
-      log_info (_("no running gpg-agent - starting one\n"));
-      
-      if (fflush (NULL))
-        {
-          log_error ("error flushing pending output: %s\n", strerror (errno));
-          return seterr (Write_Error);
-        }
+\f
+/* Ask the agent whether the certificate is in the list of trusted
+   keys */
+int
+gpgsm_agent_istrusted (ctrl_t ctrl, ksba_cert_t cert)
+{
+  int rc;
+  char *fpr;
+  char line[ASSUAN_LINELENGTH];
 
-      if (pipe (inpipe))
-        {
-          log_error ("error creating pipe: %s\n", strerror (errno));
-          return seterr (General_Error);
-        }
-      if (pipe (outpipe))
-        {
-          log_error ("error creating pipe: %s\n", strerror (errno));
-          close (inpipe[0]);
-          close (inpipe[1]);
-          return seterr (General_Error);
-        }
+  rc = start_agent (ctrl);
+  if (rc)
+    return rc;
 
-      pid = fork ();
-      if (pid == -1) 
-        return seterr (General_Error);
-
-      if (!pid)
-        { /* child */
-          int i, n;
-          char errbuf[100];
-          int log_fd = log_get_fd ();
-
-          /* close all files which will not be duped but keep stderr
-             and log_stream for now */
-          n = sysconf (_SC_OPEN_MAX);
-          if (n < 0)
-              n = MAX_OPEN_FDS;
-          for (i=0; i < n; i++)
-            {
-              if (i != fileno (stderr) && i != log_fd
-                  && i != inpipe[1] && i != outpipe[0])
-                close(i);
-            }
-          errno = 0;
-
-          if (inpipe[1] != 1)
-            {
-              if (dup2 (inpipe[1], 1) == -1)
-                {
-                  log_error ("dup2 failed in child: %s\n", strerror (errno));
-                  _exit (4);
-                }
-              close (inpipe[1]);
-            }
-          if (outpipe[0] != 0)
-            {
-              if (dup2 (outpipe[0], 0) == -1)
-                {
-                  log_error ("dup2 failed in child: %s\n", strerror (errno));
-                  _exit (4);
-                }
-              close (outpipe[0]);
-            }
-
-          /* and start it */
-          execl ("../agent/gpg-agent", "gpg-agent", "--server", NULL); 
-          /* oops - tell the parent about it */
-          snprintf (errbuf, DIM(errbuf)-1, "ERR %d execl failed: %.50s\n",
-                    ASSUAN_Problem_Starting_Server, strerror (errno));
-          errbuf[DIM(errbuf)-1] = 0;
-          writen (1, errbuf, strlen (errbuf));
-          _exit (4);
-        } /* end child */
-
-      agent_pid = pid;
-    
-      inbound_fd = inpipe[0];
-      close (inpipe[1]);
-
-      close (outpipe[0]);
-      outbound_fd = outpipe[1];
-    }
-  else
+  fpr = gpgsm_get_fingerprint_hexstring (cert, GCRY_MD_SHA1);
+  if (!fpr)
     {
-      infostr = xstrdup (infostr);
-      if ( !(p = strchr (infostr, ':')) || p == infostr
-           /* || (p-infostr)+1 >= sizeof client_addr.sun_path */)
-        {
-          log_error (_("malformed GPG_AGENT_INFO environment variable\n"));
-          xfree (infostr);
-          return seterr (General_Error);
-        }
-      *p = 0;
-      log_error (_("socket based agent communication not yet implemented\n"));
-      return seterr (Not_Implemented);
+      log_error ("error getting the fingerprint\n");
+      return gpg_error (GPG_ERR_GENERAL);
     }
 
-  inbound.eof = 0;
-  inbound.linelen = 0;
-  inbound.attic.linelen = 0;
+  snprintf (line, DIM(line)-1, "ISTRUSTED %s", fpr);
+  line[DIM(line)-1] = 0;
+  xfree (fpr);
+
+  rc = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
+  return map_assuan_err (rc);
+}
+
+/* Ask the agent to mark CERT as a trusted Root-CA one */
+int
+gpgsm_agent_marktrusted (ctrl_t ctrl, ksba_cert_t cert)
+{
+  int rc;
+  char *fpr, *dn;
+  char line[ASSUAN_LINELENGTH];
 
-  /* The server is available - read the greeting */
-  rc = read_from_agent (&okay);
+  rc = start_agent (ctrl);
   if (rc)
+    return rc;
+
+  fpr = gpgsm_get_fingerprint_hexstring (cert, GCRY_MD_SHA1);
+  if (!fpr)
     {
-      log_error ("can't connect to the agent: %s\n", gnupg_strerror (rc));
+      log_error ("error getting the fingerprint\n");
+      return gpg_error (GPG_ERR_GENERAL);
     }
-  else if (!okay)
+
+  dn = ksba_cert_get_issuer (cert, 0);
+  if (!dn)
     {
-      log_error ("can't connect to the agent: %s\n", inbound.line);
-      rc = seterr (No_Agent);
+      xfree (fpr);
+      return gpg_error (GPG_ERR_GENERAL);
     }
- else
-   log_debug ("connection to agent established\n");
+  snprintf (line, DIM(line)-1, "MARKTRUSTED %s S %s", fpr, dn);
+  line[DIM(line)-1] = 0;
+  ksba_free (dn);
+  xfree (fpr);
 
-  return 0;
+  rc = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
+  return map_assuan_err (rc);
 }
 
 
-static int
-request_reply (const char *line, struct membuf *membuf)
+\f
+/* Ask the agent whether the a corresponding secret key is available
+   for the given keygrip */
+int
+gpgsm_agent_havekey (ctrl_t ctrl, const char *hexkeygrip)
 {
-  int rc, okay;
+  int rc;
+  char line[ASSUAN_LINELENGTH];
 
-  if (DBG_AGENT)
-    log_debug ("agent-request=`%.*s'", (int)(*line? strlen(line)-1:0), line);
-  rc = writen (outbound_fd, line, strlen (line));
+  rc = start_agent (ctrl);
   if (rc)
     return rc;
- again:
-  rc = read_from_agent (&okay);
-  if (rc)
-      log_error ("error reading from agent: %s\n", gnupg_strerror (rc));
-  else if (!okay)
+
+  if (!hexkeygrip || strlen (hexkeygrip) != 40)
+    return gpg_error (GPG_ERR_INV_VALUE);
+
+  snprintf (line, DIM(line)-1, "HAVEKEY %s", hexkeygrip);
+  line[DIM(line)-1] = 0;
+
+  rc = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
+  return map_assuan_err (rc);
+}
+
+\f
+static AssuanError
+learn_cb (void *opaque, const void *buffer, size_t length)
+{
+  struct learn_parm_s *parm = opaque;
+  size_t len;
+  char *buf;
+  ksba_cert_t cert;
+  int rc;
+
+  if (parm->error)
+    return 0;
+
+  if (buffer)
     {
-      log_error ("got error from agent: %s\n", inbound.line);
-      rc = seterr (Agent_Error);
+      put_membuf (parm->data, buffer, length);
+      return 0;
     }
-  else if (okay == 2 && !membuf)
+  /* END encountered - process what we have */
+  buf = get_membuf (parm->data, &len);
+  if (!buf)
     {
-      log_error ("got unexpected data line\n");
-      rc = seterr (Agent_Error);
+      parm->error = gpg_error (GPG_ERR_ENOMEM);
+      return 0;
     }
-  else
+
+
+  /* FIXME: this should go into import.c */
+  rc = ksba_cert_new (&cert);
+  if (rc)
     {
-      if (DBG_AGENT)
-        log_debug ("agent-reply=`%s'", inbound.line);
+      parm->error = rc;
+      return 0;
+    }
+  rc = ksba_cert_init_from_mem (cert, buf, len);
+  if (rc)
+    {
+      log_error ("failed to parse a certificate: %s\n", gpg_strerror (rc));
+      ksba_cert_release (cert);
+      parm->error = rc;
+      return 0;
     }
 
-  if (!rc && okay == 2 && inbound.linelen >= 2)
-    { /* handle data line */
-      unsigned char *buf = inbound.line;
-      size_t len = inbound.linelen;
-      unsigned char *p;
-
-      buf += 2;
-      len -= 2;
+  rc = gpgsm_basic_cert_check (cert);
+  if (gpg_err_code (rc) == GPG_ERR_MISSING_CERT)
+    { /* For later use we store it in the ephemeral database. */
+      log_info ("issuer certificate missing - storing as ephemeral\n");
+      keydb_store_cert (cert, 1, NULL);
+    }
+  else if (rc)
+    log_error ("invalid certificate: %s\n", gpg_strerror (rc));
+  else
+    {
+      int existed;
 
-      p = buf;
-      while (len)
+      if (!keydb_store_cert (cert, 0, &existed))
         {
-          for (;len && *p != '%'; len--, p++)
-            ;
-          put_membuf (membuf, buf, p-buf);
-          if (len>2)
-            { /* handle escaping */
-              unsigned char tmp[1];
-              p++;
-              *tmp = xtoi_2 (p);
-              p += 2;
-              len -= 3;
-              put_membuf (membuf, tmp, 1);
-            }
-          buf = p;
+          if (opt.verbose > 1 && existed)
+            log_info ("certificate already in DB\n");
+          else if (opt.verbose && !existed)
+            log_info ("certificate imported\n");
         }
-      goto again;
     }
-  return rc;
-}
-
-
 
-\f
-/* Call the agent to do a sign operation using the key identified by
-   the hex string KEYGRIP. */
+  ksba_cert_release (cert);
+  init_membuf (parm->data, 4096);
+  return 0;
+}
+  
+/* Call the agent to learn about a smartcard */
 int
-gpgsm_agent_pksign (const char *keygrip,
-                    unsigned char *digest, size_t digestlen, int digestalgo,
-                    char **r_buf, size_t *r_buflen )
+gpgsm_agent_learn (ctrl_t ctrl)
 {
-  int rc, i;
-  char *p, line[LINELENGTH];
-  struct membuf data;
+  int rc;
+  struct learn_parm_s learn_parm;
+  membuf_t data;
   size_t len;
 
-  *r_buf = NULL;
-  rc = start_agent ();
+  rc = start_agent (ctrl);
   if (rc)
     return rc;
 
-  if (digestlen*2 + 50 > DIM(line))
-    return seterr (General_Error);
-
-  rc = request_reply ("RESET\n", NULL);
+  init_membuf (&data, 4096);
+  learn_parm.error = 0;
+  learn_parm.ctx = agent_ctx;
+  learn_parm.data = &data;
+  rc = assuan_transact (agent_ctx, "LEARN --send",
+                        learn_cb, &learn_parm, 
+                        NULL, NULL, NULL, NULL);
+  xfree (get_membuf (&data, &len));
   if (rc)
-    return rc;
+    return map_assuan_err (rc);
+  return learn_parm.error;
+}
 
-  snprintf (line, DIM(line)-1, "SIGKEY %s\n", keygrip);
-  line[DIM(line)-1] = 0;
-  rc = request_reply (line, NULL);
-  if (rc)
-    return rc;
+\f
+/* Ask the agent to change the passphrase of the key identified by
+   HEXKEYGRIP. If DESC is not NULL, display instead of the default
+   description message. */
+int
+gpgsm_agent_passwd (ctrl_t ctrl, const char *hexkeygrip, const char *desc)
+{
+  int rc;
+  char line[ASSUAN_LINELENGTH];
 
-  sprintf (line, "SETHASH %d ", digestalgo);
-  p = line + strlen (line);
-  for (i=0; i < digestlen ; i++, p += 2 )
-    sprintf (p, "%02X", digest[i]);
-  strcpy (p, "\n");
-  rc = request_reply (line, NULL);
+  rc = start_agent (ctrl);
   if (rc)
     return rc;
 
-  init_membuf (&data, 1024);
-  rc = request_reply ("PKSIGN\n", &data);
-  if (rc)
+  if (!hexkeygrip || strlen (hexkeygrip) != 40)
+    return gpg_error (GPG_ERR_INV_VALUE);
+
+  if (desc)
     {
-      xfree (get_membuf (&data, &len));
-      return rc;
+      snprintf (line, DIM(line)-1, "SETKEYDESC %s", desc);
+      line[DIM(line)-1] = 0;
+      rc = assuan_transact (agent_ctx, line,
+                            NULL, NULL, NULL, NULL, NULL, NULL);
+      if (rc)
+        return map_assuan_err (rc);
     }
-  *r_buf = get_membuf (&data, r_buflen);
-/*    if (DBG_AGENT && *r_buf) */
-/*      {  */
-/*        FILE *fp; */
-/*        char fname[100]; */
-      
-/*        memcpy (fname, keygrip, 40); */
-/*        strcpy (fname+40, "_pksign-dump.tmp"); */
-/*        fp = fopen (fname, "wb"); */
-/*        fwrite (*r_buf, *r_buflen, 1, fp); */
-/*        fclose (fp); */
-/*    } */
-
-  return *r_buf? 0 : GNUPG_Out_Of_Core;
-}
-
 
+  snprintf (line, DIM(line)-1, "PASSWD %s", hexkeygrip);
+  line[DIM(line)-1] = 0;
 
+  rc = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
+  return map_assuan_err (rc);
+}