2007-07-17 Marcus Brinkmann <marcus@g10code.de>
[gpgme.git] / gpgme / keylist.c
index 09cb89f..b56131c 100644 (file)
@@ -1,22 +1,23 @@
 /* keylist.c - Listing keys.
    Copyright (C) 2000 Werner Koch (dd9jn)
-   Copyright (C) 2001, 2002 g10 Code GmbH
+   Copyright (C) 2001, 2002, 2003, 2004, 2006, 2007 g10 Code GmbH
 
    This file is part of GPGME.
  
    GPGME is free software; you can redistribute it and/or modify it
-   under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 2 of the License, or
-   (at your option) any later version.
+   under the terms of the GNU Lesser General Public License as
+   published by the Free Software Foundation; either version 2.1 of
+   the License, or (at your option) any later version.
+   
    GPGME is distributed in the hope that it will be useful, but
    WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-   General Public License for more details.
-   You should have received a copy of the GNU General Public License
-   along with GPGME; if not, write to the Free Software Foundation,
-   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+   Lesser General Public License for more details.
+   
+   You should have received a copy of the GNU Lesser General Public
+   License along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+   02111-1307, USA.  */
 
 #if HAVE_CONFIG_H
 #include <config.h>
 #include <time.h>
 #include <assert.h>
 #include <ctype.h>
+#include <errno.h>
 
+#include "gpgme.h"
 #include "util.h"
 #include "context.h"
 #include "ops.h"
-#include "key.h"
+#include "debug.h"
 
 \f
-struct keylist_result_s
+struct key_queue_item_s
 {
-  int truncated;
-  GpgmeData xmlinfo;
+  struct key_queue_item_s *next;
+  gpgme_key_t key;
 };
 
-
-void
-_gpgme_release_keylist_result (KeylistResult result)
+typedef struct
 {
-  if (!result)
-    return;
-  free (result);
-}
+  struct _gpgme_op_keylist_result result;
+
+  gpgme_key_t tmp_key;
+
+  /* This points to the last uid in tmp_key.  */
+  gpgme_user_id_t tmp_uid;
+
+  /* This points to the last sig in tmp_uid.  */
+  gpgme_key_sig_t tmp_keysig;
+
+  /* Something new is available.  */
+  int key_cond;
+  struct key_queue_item_s *key_queue;
+} *op_data_t;
 
 
-/* Append some XML info.  args is currently ignore but we might want
-   to add more information in the future (like source of the
-   keylisting.  With args of NULL the XML structure is closed.  */
 static void
-append_xml_keylistinfo (GpgmeData *rdh, char *args)
+release_op_data (void *hook)
 {
-  GpgmeData dh;
+  op_data_t opd = (op_data_t) hook;
+  struct key_queue_item_s *key = opd->key_queue;
 
-  if (!*rdh)
-    {
-      if (gpgme_data_new (rdh))
-       return; /* FIXME: We are ignoring out-of-core.  */
-      dh = *rdh;
-      _gpgme_data_append_string (dh, "<GnupgOperationInfo>\n");
-    }
-  else
-    {
-      dh = *rdh;
-      _gpgme_data_append_string (dh, "  </keylisting>\n");
-    }
+  if (opd->tmp_key)
+    gpgme_key_unref (opd->tmp_key);
 
-  if (!args)
+  /* opd->tmp_uid and opd->tmp_keysig are actually part of opd->tmp_key,
+     so we do not need to release them here.  */
+
+  while (key)
     {
-      /* Just close the XML containter.  */
-      _gpgme_data_append_string (dh, "</GnupgOperationInfo>\n");
-      return;
-    }
+      struct key_queue_item_s *next = key->next;
 
-  _gpgme_data_append_string (dh, "  <keylisting>\n    <truncated/>\n");
-    
+      gpgme_key_unref (key->key);
+      key = next;
+    }
 }
 
 
-static void
-keylist_status_handler (GpgmeCtx ctx, GpgmeStatusCode code, char *args)
+gpgme_keylist_result_t
+gpgme_op_keylist_result (gpgme_ctx_t ctx)
 {
-  if (ctx->error)
-    return;
-  test_and_allocate_result (ctx, keylist);
+  void *hook;
+  op_data_t opd;
+  gpgme_error_t err;
 
-   switch (code)
+  err = _gpgme_op_data_lookup (ctx, OPDATA_KEYLIST, &hook, -1, NULL);
+  opd = hook;
+  if (err || !opd)
+    return NULL;
+
+  return &opd->result;
+}
+
+\f
+static gpgme_error_t
+keylist_status_handler (void *priv, gpgme_status_code_t code, char *args)
+{
+  gpgme_ctx_t ctx = (gpgme_ctx_t) priv;
+  gpgme_error_t err;
+  void *hook;
+  op_data_t opd;
+
+  err = _gpgme_op_data_lookup (ctx, OPDATA_KEYLIST, &hook, -1, NULL);
+  opd = hook;
+  if (err)
+    return err;
+
+  switch (code)
     {
     case GPGME_STATUS_TRUNCATED:
-      ctx->result.keylist->truncated = 1;
-      break;
-
-    case GPGME_STATUS_EOF:
-      if (ctx->result.keylist->truncated)
-        append_xml_keylistinfo (&ctx->result.keylist->xmlinfo, "1");
-      if (ctx->result.keylist->xmlinfo)
-       {
-         append_xml_keylistinfo (&ctx->result.keylist->xmlinfo, NULL);
-         _gpgme_set_op_info (ctx, ctx->result.keylist->xmlinfo);
-         ctx->result.keylist->xmlinfo = NULL;
-        }
+      opd->result.truncated = 1;
       break;
 
     default:
-      /* Ignore all other codes.  */
       break;
     }
+  return 0;
 }
 
 \f
-static time_t
-parse_timestamp (char *timestamp)
+static void
+set_subkey_trust_info (gpgme_subkey_t subkey, const char *src)
 {
-  if (!*timestamp)
-    return 0;
+  while (*src && !isdigit (*src))
+    {
+      switch (*src)
+       {
+       case 'e':
+         subkey->expired = 1;
+         break;
+
+       case 'r':
+         subkey->revoked = 1;
+         break;
 
-  return (time_t) strtoul (timestamp, NULL, 10);
+       case 'd':
+          /* Note that gpg 1.3 won't print that anymore but only uses
+             the capabilities field. */
+         subkey->disabled = 1;
+         break;
+
+       case 'i':
+         subkey->invalid = 1;
+         break;
+        }
+      src++;
+    }
 }
 
 
 static void
-set_mainkey_trust_info (GpgmeKey key, const char *src)
+set_mainkey_trust_info (gpgme_key_t key, const char *src)
 {
-  /* Look at letters and stop at the first digit.  */
+  /* First set the trust info of the main key (the first subkey).  */
+  set_subkey_trust_info (key->subkeys, src);
+
+  /* Now set the summarized trust info.  */
   while (*src && !isdigit (*src))
     {
       switch (*src)
        {
        case 'e':
-         key->keys.flags.expired = 1;
+         key->expired = 1;
          break;
 
        case 'r':
-         key->keys.flags.revoked = 1;
+         key->revoked = 1;
          break;
 
        case 'd':
-         key->keys.flags.disabled = 1;
+          /* Note that gpg 1.3 won't print that anymore but only uses
+             the capabilities field.  However, it is still used for
+             external key listings.  */
+         key->disabled = 1;
          break;
 
        case 'i':
-         key->keys.flags.invalid = 1;
+         key->invalid = 1;
          break;
         }
       src++;
@@ -154,9 +191,9 @@ set_mainkey_trust_info (GpgmeKey key, const char *src)
 
 
 static void
-set_userid_flags (GpgmeKey key, const char *src)
+set_userid_flags (gpgme_key_t key, const char *src)
 {
-  struct user_id_s *uid = key->last_uid;
+  gpgme_user_id_t uid = key->_last_uid;
 
   assert (uid);
   /* Look at letters and stop at the first digit.  */
@@ -194,63 +231,34 @@ set_userid_flags (GpgmeKey key, const char *src)
 
 
 static void
-set_subkey_trust_info (struct subkey_s *subkey, const char *src)
-{
-  /* Look at letters and stop at the first digit.  */
-  while (*src && !isdigit (*src))
-    {
-      switch (*src)
-       {
-       case 'e':
-         subkey->flags.expired = 1;
-         break;
-
-       case 'r':
-         subkey->flags.revoked = 1;
-         break;
-
-       case 'd':
-         subkey->flags.disabled = 1;
-         break;
-
-       case 'i':
-         subkey->flags.invalid = 1;
-         break;
-        }
-      src++;
-    }
-}
-
-
-static void
-set_mainkey_capability (GpgmeKey key, const char *src)
+set_subkey_capability (gpgme_subkey_t subkey, const char *src)
 {
   while (*src)
     {
       switch (*src)
        {
        case 'e':
-         key->keys.flags.can_encrypt = 1;
+         subkey->can_encrypt = 1;
          break;
 
        case 's':
-         key->keys.flags.can_sign = 1;
+         subkey->can_sign = 1;
          break;
 
        case 'c':
-         key->keys.flags.can_certify = 1;
+         subkey->can_certify = 1;
          break;
 
-       case 'E':
-         key->gloflags.can_encrypt = 1;
+       case 'a':
+         subkey->can_authenticate = 1;
          break;
 
-       case 'S':
-         key->gloflags.can_sign = 1;
+       case 'q':
+         subkey->is_qualified = 1;
          break;
 
-       case 'C':
-         key->gloflags.can_certify = 1;
+       case 'd':
+         subkey->disabled = 1;
          break;
         }
       src++;
@@ -259,30 +267,57 @@ set_mainkey_capability (GpgmeKey key, const char *src)
 
 
 static void
-set_subkey_capability (struct subkey_s *subkey, const char *src)
+set_mainkey_capability (gpgme_key_t key, const char *src)
 {
+  /* First set the capabilities of the main key (the first subkey).  */
+  set_subkey_capability (key->subkeys, src);
+
   while (*src)
     {
       switch (*src)
        {
+       case 'd':
+        case 'D':
+          /* Note, that this flag is also set using the key validity
+             field for backward compatibility with gpg 1.2.  We use d
+             and D, so that a future gpg version will be able to
+             disable certain subkeys. Currently it is expected that
+             gpg sets this for the primary key. */
+                 key->disabled = 1;
+          break;
+
        case 'e':
-         subkey->flags.can_encrypt = 1;
+       case 'E':
+         key->can_encrypt = 1;
          break;
 
        case 's':
-         subkey->flags.can_sign = 1;
+       case 'S':
+         key->can_sign = 1;
          break;
 
        case 'c':
-         subkey->flags.can_certify = 1;
+       case 'C':
+         key->can_certify = 1;
+         break;
+
+       case 'a':
+       case 'A':
+         key->can_authenticate = 1;
+         break;
+
+       case 'q':
+       case 'Q':
+         key->is_qualified = 1;
          break;
         }
       src++;
     }
 }
 
+
 static void
-set_ownertrust (GpgmeKey key, const char *src)
+set_ownertrust (gpgme_key_t key, const char *src)
 {
   /* Look at letters and stop at the first digit.  */
   while (*src && !isdigit (*src))
@@ -290,23 +325,23 @@ set_ownertrust (GpgmeKey key, const char *src)
       switch (*src)
        {
        case 'n':
-         key->otrust = GPGME_VALIDITY_NEVER;
+         key->owner_trust = GPGME_VALIDITY_NEVER;
          break;
 
        case 'm':
-         key->otrust = GPGME_VALIDITY_MARGINAL;
+         key->owner_trust = GPGME_VALIDITY_MARGINAL;
          break;
 
        case 'f':
-         key->otrust = GPGME_VALIDITY_FULL;
+         key->owner_trust = GPGME_VALIDITY_FULL;
          break;
 
        case 'u':
-         key->otrust = GPGME_VALIDITY_ULTIMATE;
+         key->owner_trust = GPGME_VALIDITY_ULTIMATE;
          break;
 
         default:
-         key->otrust = GPGME_VALIDITY_UNKNOWN;
+         key->owner_trust = GPGME_VALIDITY_UNKNOWN;
          break;
         }
       src++;
@@ -314,14 +349,16 @@ set_ownertrust (GpgmeKey key, const char *src)
 }
 
 
-/* We have read an entire key into ctx->tmp_key and should now finish
-   it.  It is assumed that this releases ctx->tmp_key.  */
+/* We have read an entire key into tmp_key and should now finish it.
+   It is assumed that this releases tmp_key.  */
 static void
-finish_key (GpgmeCtx ctx)
+finish_key (gpgme_ctx_t ctx, op_data_t opd)
 {
-  GpgmeKey key = ctx->tmp_key;
+  gpgme_key_t key = opd->tmp_key;
 
-  ctx->tmp_key = NULL;
+  opd->tmp_key = NULL;
+  opd->tmp_uid = NULL;
+  opd->tmp_keysig = NULL;
 
   if (key)
     _gpgme_engine_io_event (ctx->engine, GPGME_EVENT_NEXT_KEY, key);
@@ -329,33 +366,41 @@ finish_key (GpgmeCtx ctx)
 
 
 /* Note: We are allowed to modify LINE.  */
-static void
-keylist_colon_handler (GpgmeCtx ctx, char *line)
+static gpgme_error_t
+keylist_colon_handler (void *priv, char *line)
 {
+  gpgme_ctx_t ctx = (gpgme_ctx_t) priv;
   enum
     {
-      RT_NONE, RT_SIG, RT_UID, RT_SUB, RT_PUB, RT_FPR, RT_SSB, RT_SEC,
-      RT_CRT, RT_CRS, RT_REV
+      RT_NONE, RT_SIG, RT_UID, RT_SUB, RT_PUB, RT_FPR,
+      RT_SSB, RT_SEC, RT_CRT, RT_CRS, RT_REV, RT_SPK
     }
   rectype = RT_NONE;
-#define NR_FIELDS 13
+#define NR_FIELDS 16
   char *field[NR_FIELDS];
   int fields = 0;
-  GpgmeKey key = ctx->tmp_key;
-  struct subkey_s *subkey = NULL;
-  struct certsig_s *certsig = NULL;
+  void *hook;
+  op_data_t opd;
+  gpgme_error_t err;
+  gpgme_key_t key;
+  gpgme_subkey_t subkey = NULL;
+  gpgme_key_sig_t keysig = NULL;
+
+  err = _gpgme_op_data_lookup (ctx, OPDATA_KEYLIST, &hook, -1, NULL);
+  opd = hook;
+  if (err)
+    return err;
 
-  DEBUG3 ("keylist_colon_handler ctx = %p, key = %p, line = %s\n",
-         ctx, key, line ? line : "(null)");
+  key = opd->tmp_key;
 
-  if (ctx->error)
-    return;
+  TRACE2 (DEBUG_CTX, "gpgme:keylist_colon_handler", ctx,
+         "key = %p, line = %s", key, line ? line : "(null)");
 
   if (!line)
     {
       /* End Of File.  */
-      finish_key (ctx);
-      return
+      finish_key (ctx, opd);
+      return 0;
     }
 
   while (line && fields < NR_FIELDS)
@@ -370,88 +415,24 @@ keylist_colon_handler (GpgmeCtx ctx, char *line)
     rectype = RT_SIG;
   else if (!strcmp (field[0], "rev"))
     rectype = RT_REV;
-  else if (!strcmp (field[0], "uid") && key)
-    rectype = RT_UID;
-  else if (!strcmp (field[0], "sub") && key)
-    {
-      /* Start a new subkey.  */
-      rectype = RT_SUB; 
-      if (!(subkey = _gpgme_key_add_subkey (key)))
-       {
-         ctx->error = mk_error (Out_Of_Core);
-         return;
-       }
-    }
-  else if (!strcmp (field[0], "ssb") && key)
-    {
-      /* Start a new secret subkey.  */
-      rectype = RT_SSB;
-      if (!(subkey = _gpgme_key_add_secret_subkey (key)))
-       {
-         ctx->error = mk_error (Out_Of_Core);
-         return;
-       }
-    }
   else if (!strcmp (field[0], "pub"))
-    {
-      /* Start a new keyblock.  */
-      if (_gpgme_key_new (&key))
-       {
-         /* The only kind of error we can get.  */
-         ctx->error = mk_error (Out_Of_Core);
-         return;
-       }
-      rectype = RT_PUB;
-      finish_key (ctx);
-      assert (!ctx->tmp_key);
-      ctx->tmp_key = key;
-    }
+    rectype = RT_PUB;
   else if (!strcmp (field[0], "sec"))
-    {
-      /* Start a new keyblock,  */
-      if (_gpgme_key_new_secret (&key))
-       {
-         /* The only kind of error we can get.  */
-         ctx->error = mk_error (Out_Of_Core);
-         return;
-       }
-      rectype = RT_SEC;
-      finish_key (ctx);
-      assert (!ctx->tmp_key);
-      ctx->tmp_key = key;
-    }
+    rectype = RT_SEC;
   else if (!strcmp (field[0], "crt"))
-    {
-      /* Start a new certificate.  */
-      if (_gpgme_key_new (&key))
-       {
-         /* The only kind of error we can get.  */
-         ctx->error = mk_error (Out_Of_Core);
-         return;
-       }
-      key->x509 = 1;
-      rectype = RT_CRT;
-      finish_key (ctx);
-      assert (!ctx->tmp_key);
-      ctx->tmp_key = key;
-    }
+    rectype = RT_CRT;
   else if (!strcmp (field[0], "crs"))
-    {
-      /* Start a new certificate.  */
-      if (_gpgme_key_new_secret (&key))
-       {
-         /* The only kind of error we can get.  */
-         ctx->error = mk_error (Out_Of_Core);
-         return;
-       }
-      key->x509 = 1;
-      rectype = RT_CRS;
-      finish_key (ctx);
-      assert (!ctx->tmp_key);
-      ctx->tmp_key = key;
-    }
+    rectype = RT_CRS;
   else if (!strcmp (field[0], "fpr") && key) 
     rectype = RT_FPR;
+  else if (!strcmp (field[0], "uid") && key)
+    rectype = RT_UID;
+  else if (!strcmp (field[0], "sub") && key)
+    rectype = RT_SUB; 
+  else if (!strcmp (field[0], "ssb") && key)
+    rectype = RT_SSB;
+  else if (!strcmp (field[0], "spk") && key)
+    rectype = RT_SPK;
   else 
     rectype = RT_NONE;
 
@@ -459,29 +440,39 @@ keylist_colon_handler (GpgmeCtx ctx, char *line)
      this, clear the user ID pointer when encountering anything but a
      signature.  */
   if (rectype != RT_SIG && rectype != RT_REV)
-    ctx->tmp_uid = NULL;
+    opd->tmp_uid = NULL;
+
+  /* Only look at subpackets immediately following a signature.  For
+     this, clear the signature pointer when encountering anything but
+     a subpacket.  */
+  if (rectype != RT_SPK)
+    opd->tmp_keysig = NULL;
 
   switch (rectype)
     {
+    case RT_PUB:
+    case RT_SEC:
     case RT_CRT:
     case RT_CRS:
-      /* Field 8 has the X.509 serial number.  */
-      if (fields >= 8)
+      /* Start a new keyblock.  */
+      err = _gpgme_key_new (&key);
+      if (err)
+       return err;
+      key->keylist_mode = ctx->keylist_mode;
+      err = _gpgme_key_add_subkey (key, &subkey);
+      if (err)
        {
-         key->issuer_serial = strdup (field[7]);
-         if (!key->issuer_serial)
-           ctx->error = mk_error (Out_Of_Core);
+         gpgme_key_unref (key);
+         return err;
        }
 
-      /* Field 10 is not used for gpg due to --fixed-list-mode option
-        but GPGSM stores the issuer name.  */
-      if (fields >= 10 && _gpgme_decode_c_string (field[9],
-                                                 &key->issuer_name, 0))
-         ctx->error = mk_error (Out_Of_Core);
-      /* Fall through!  */
+      if (rectype == RT_SEC || rectype == RT_CRS)
+       key->secret = subkey->secret = 1;
+      if (rectype == RT_CRT || rectype == RT_CRS)
+       key->protocol = GPGME_PROTOCOL_CMS;
+      finish_key (ctx, opd);
+      opd->tmp_key = key;
 
-    case RT_PUB:
-    case RT_SEC:
       /* Field 2 has the trust info.  */
       if (fields >= 2)
        set_mainkey_trust_info (key, field[1]);
@@ -492,7 +483,7 @@ keylist_colon_handler (GpgmeCtx ctx, char *line)
          int i = atoi (field[2]);
          /* Ignore invalid values.  */
          if (i > 1)
-           key->keys.key_len = i; 
+           subkey->length = i; 
        }
 
       /* Field 4 has the public key algorithm.  */
@@ -500,34 +491,64 @@ keylist_colon_handler (GpgmeCtx ctx, char *line)
        {
          int i = atoi (field[3]);
          if (i >= 1 && i < 128)
-           key->keys.key_algo = i;
+           subkey->pubkey_algo = i;
        }
 
-      /* Field 5 has the long keyid.  */
-      if (fields >= 5 && strlen (field[4]) == DIM(key->keys.keyid) - 1)
-       strcpy (key->keys.keyid, field[4]);
+      /* Field 5 has the long keyid.  Allow short key IDs for the
+        output of an external keyserver listing.  */
+      if (fields >= 5 && strlen (field[4]) <= DIM(subkey->_keyid) - 1)
+       strcpy (subkey->_keyid, field[4]);
 
       /* Field 6 has the timestamp (seconds).  */
       if (fields >= 6)
-       key->keys.timestamp = parse_timestamp (field[5]);
+       subkey->timestamp = _gpgme_parse_timestamp (field[5], NULL);
 
       /* Field 7 has the expiration time (seconds).  */
       if (fields >= 7)
-       key->keys.expires_at = parse_timestamp (field[6]);
+       subkey->expires = _gpgme_parse_timestamp (field[6], NULL);
 
+      /* Field 8 has the X.509 serial number.  */
+      if (fields >= 8 && (rectype == RT_CRT || rectype == RT_CRS))
+       {
+         key->issuer_serial = strdup (field[7]);
+         if (!key->issuer_serial)
+           return gpg_error_from_errno (errno);
+       }
+         
       /* Field 9 has the ownertrust.  */
       if (fields >= 9)
        set_ownertrust (key, field[8]);
 
+      /* Field 10 is not used for gpg due to --fixed-list-mode option
+        but GPGSM stores the issuer name.  */
+      if (fields >= 10 && (rectype == RT_CRT || rectype == RT_CRS))
+       if (_gpgme_decode_c_string (field[9], &key->issuer_name, 0))
+         return gpg_error (GPG_ERR_ENOMEM);    /* FIXME */
+
       /* Field 11 has the signature class.  */
 
       /* Field 12 has the capabilities.  */
       if (fields >= 12)
        set_mainkey_capability (key, field[11]);
+
+      /* Field 15 carries special flags of a secret key.  We reset the
+         SECRET flag of a subkey here if the key is actually only a
+         stub. The SECRET flag of the key will be true even then. */
+      if (fields >= 15 && key->secret)
+        if (*field[14] == '#')
+          subkey->secret = 0;
       break;
 
     case RT_SUB:
     case RT_SSB:
+      /* Start a new subkey.  */
+      err = _gpgme_key_add_subkey (key, &subkey);
+      if (err)
+       return err;
+
+      if (rectype == RT_SSB)
+       subkey->secret = 1;
+
       /* Field 2 has the trust info.  */
       if (fields >= 2)
        set_subkey_trust_info (subkey, field[1]);
@@ -538,7 +559,7 @@ keylist_colon_handler (GpgmeCtx ctx, char *line)
          int i = atoi (field[2]);
          /* Ignore invalid values.  */
          if (i > 1)
-           subkey->key_len = i;
+           subkey->length = i;
        }
 
       /* Field 4 has the public key algorithm.  */
@@ -546,20 +567,20 @@ keylist_colon_handler (GpgmeCtx ctx, char *line)
        {
          int i = atoi (field[3]);
          if (i >= 1 && i < 128)
-           subkey->key_algo = i;
+           subkey->pubkey_algo = i;
        }
 
       /* Field 5 has the long keyid.  */
-      if (fields >= 5 && strlen (field[4]) == DIM(subkey->keyid) - 1)
-       strcpy (subkey->keyid, field[4]);
+      if (fields >= 5 && strlen (field[4]) == DIM(subkey->_keyid) - 1)
+       strcpy (subkey->_keyid, field[4]);
 
       /* Field 6 has the timestamp (seconds).  */
       if (fields >= 6)
-       subkey->timestamp = parse_timestamp (field[5]);
+       subkey->timestamp = _gpgme_parse_timestamp (field[5], NULL);
 
       /* Field 7 has the expiration time (seconds).  */
       if (fields >= 7)
-       subkey->expires_at = parse_timestamp (field[6]);
+       subkey->expires = _gpgme_parse_timestamp (field[6], NULL);
 
       /* Field 8 is reserved (LID).  */
       /* Field 9 has the ownertrust.  */
@@ -570,6 +591,11 @@ keylist_colon_handler (GpgmeCtx ctx, char *line)
       /* Field 12 has the capabilities.  */
       if (fields >= 12)
        set_subkey_capability (subkey, field[11]);
+
+      /* Field 15 carries special flags of a secret key. */
+      if (fields >= 15 && key->secret)
+        if (*field[14] == '#')
+          subkey->secret = 0;
       break;
 
     case RT_UID:
@@ -577,23 +603,29 @@ keylist_colon_handler (GpgmeCtx ctx, char *line)
       if (fields >= 10)
        {
          if (_gpgme_key_append_name (key, field[9]))
-           ctx->error = mk_error (Out_Of_Core);
+           return gpg_error_from_errno (GPG_ERR_ENOMEM);       /* FIXME */
          else
            {
              if (field[1])
                set_userid_flags (key, field[1]);
-             ctx->tmp_uid = key->last_uid;
+             opd->tmp_uid = key->_last_uid;
            }
        }
       break;
 
     case RT_FPR:
       /* Field 10 has the fingerprint (take only the first one).  */
-      if (fields >= 10 && !key->keys.fingerprint && field[9] && *field[9])
+      if (fields >= 10 && field[9] && *field[9])
        {
-         key->keys.fingerprint = strdup (field[9]);
-         if (!key->keys.fingerprint)
-           ctx->error = mk_error (Out_Of_Core);
+          /* Need to apply it to the last subkey because all subkeys
+             do have fingerprints. */
+          subkey = key->_last_subkey;
+          if (!subkey->fpr)
+            {
+              subkey->fpr = strdup (field[9]);
+              if (!subkey->fpr)
+                return gpg_error_from_errno (errno);
+            }
        }
 
       /* Field 13 has the gpgsm chain ID (take only the first one).  */
@@ -601,46 +633,43 @@ keylist_colon_handler (GpgmeCtx ctx, char *line)
        {
          key->chain_id = strdup (field[12]);
          if (!key->chain_id)
-           ctx->error = mk_error (Out_Of_Core);
+           return gpg_error_from_errno (errno);
        }
       break;
 
     case RT_SIG:
     case RT_REV:
-      if (!ctx->tmp_uid)
-       return;
+      if (!opd->tmp_uid)
+       return 0;
 
       /* Start a new (revoked) signature.  */
-      assert (ctx->tmp_uid == key->last_uid);
-      certsig = _gpgme_key_add_certsig (key, (fields >= 10) ? field[9] : NULL);
-      if (!certsig)
-       {
-         ctx->error = mk_error (Out_Of_Core);
-         return;
-       }
+      assert (opd->tmp_uid == key->_last_uid);
+      keysig = _gpgme_key_add_sig (key, (fields >= 10) ? field[9] : NULL);
+      if (!keysig)
+       return gpg_error (GPG_ERR_ENOMEM);      /* FIXME */
 
       /* Field 2 has the calculated trust ('!', '-', '?', '%').  */
       if (fields >= 2)
        switch (field[1][0])
          {
          case '!':
-           certsig->sig_stat = GPGME_SIG_STAT_GOOD;
+           keysig->status = gpg_error (GPG_ERR_NO_ERROR);
            break;
 
          case '-':
-           certsig->sig_stat = GPGME_SIG_STAT_BAD;
+           keysig->status = gpg_error (GPG_ERR_BAD_SIGNATURE);
            break;
 
          case '?':
-           certsig->sig_stat = GPGME_SIG_STAT_NOKEY;
+           keysig->status = gpg_error (GPG_ERR_NO_PUBKEY);
            break;
 
          case '%':
-           certsig->sig_stat = GPGME_SIG_STAT_ERROR;
+           keysig->status = gpg_error (GPG_ERR_GENERAL);
            break;
 
          default:
-           certsig->sig_stat = GPGME_SIG_STAT_NONE;
+           keysig->status = gpg_error (GPG_ERR_NO_ERROR);
            break;
          }
 
@@ -649,243 +678,230 @@ keylist_colon_handler (GpgmeCtx ctx, char *line)
        {
          int i = atoi (field[3]);
          if (i >= 1 && i < 128)
-           certsig->algo = i;
+           keysig->pubkey_algo = i;
        }
       
       /* Field 5 has the long keyid.  */
-      if (fields >= 5 && strlen (field[4]) == DIM(certsig->keyid) - 1)
-       strcpy (certsig->keyid, field[4]);
+      if (fields >= 5 && strlen (field[4]) == DIM(keysig->_keyid) - 1)
+       strcpy (keysig->_keyid, field[4]);
       
       /* Field 6 has the timestamp (seconds).  */
       if (fields >= 6)
-       certsig->timestamp = parse_timestamp (field[5]);
+       keysig->timestamp = _gpgme_parse_timestamp (field[5], NULL);
 
       /* Field 7 has the expiration time (seconds).  */
       if (fields >= 7)
-       certsig->expires_at = parse_timestamp (field[6]);
+       keysig->expires = _gpgme_parse_timestamp (field[6], NULL);
 
       /* Field 11 has the signature class (eg, 0x30 means revoked).  */
       if (fields >= 11)
        if (field[10][0] && field[10][1])
          {
-           int class = _gpgme_hextobyte (field[10]);
-           if (class >= 0)
+           int sig_class = _gpgme_hextobyte (field[10]);
+           if (sig_class >= 0)
              {
-               certsig->sig_class = class;
-               if (class == 0x30)
-                 certsig->flags.revoked = 1;
+               keysig->sig_class = sig_class;
+               keysig->class = keysig->sig_class;
+               if (sig_class == 0x30)
+                 keysig->revoked = 1;
              }
            if (field[10][2] == 'x')
-             certsig->flags.exportable = 1;
+             keysig->exportable = 1;
          }
+
+      opd->tmp_keysig = keysig;
       break;
 
+    case RT_SPK:
+      if (!opd->tmp_keysig)
+       return 0;
+      assert (opd->tmp_keysig == key->_last_uid->_last_keysig);
+
+      if (fields >= 4)
+       {
+         /* Field 2 has the subpacket type.  */
+         int type = atoi (field[1]);
+
+         /* Field 3 has the flags.  */
+         int flags = atoi (field[2]);
+
+         /* Field 4 has the length.  */
+         int len = atoi (field[3]);
+
+         /* Field 5 has the data.  */
+         char *data = field[4];
+
+         /* Type 20: Notation data.  */
+         /* Type 26: Policy URL.  */
+         if (type == 20 || type == 26)
+           {
+             gpgme_sig_notation_t notation;
+
+             keysig = opd->tmp_keysig;
+
+             /* At this time, any error is serious.  */
+             err = _gpgme_parse_notation (&notation, type, flags, len, data);
+             if (err)
+               return err;
+
+             /* Add a new notation.  FIXME: Could be factored out.  */
+             if (!keysig->notations)
+               keysig->notations = notation;
+             if (keysig->_last_notation)
+               keysig->_last_notation->next = notation;
+             keysig->_last_notation = notation;
+           }
+       }
+    
     case RT_NONE:
       /* Unknown record.  */
       break;
     }
+  return 0;
 }
 
 
 void
-_gpgme_op_keylist_event_cb (void *data, GpgmeEventIO type, void *type_data)
+_gpgme_op_keylist_event_cb (void *data, gpgme_event_io_t type, void *type_data)
 {
-  GpgmeCtx ctx = (GpgmeCtx) data;
-  GpgmeKey key = (GpgmeKey) type_data;
+  gpgme_error_t err;
+  gpgme_ctx_t ctx = (gpgme_ctx_t) data;
+  gpgme_key_t key = (gpgme_key_t) type_data;
+  void *hook;
+  op_data_t opd;
   struct key_queue_item_s *q, *q2;
 
   assert (type == GPGME_EVENT_NEXT_KEY);
 
-  _gpgme_key_cache_add (key);
+  err = _gpgme_op_data_lookup (ctx, OPDATA_KEYLIST, &hook, -1, NULL);
+  opd = hook;
+  if (err)
+    return;
 
   q = malloc (sizeof *q);
   if (!q)
     {
-      gpgme_key_release (key);
-      ctx->error = mk_error (Out_Of_Core);
+      gpgme_key_unref (key);
+      /* FIXME       return GPGME_Out_Of_Core; */
       return;
     }
   q->key = key;
   q->next = NULL;
-  /* FIXME: Lock queue.  Use a tail pointer?  */
-  if (!(q2 = ctx->key_queue))
-    ctx->key_queue = q;
+  /* FIXME: Use a tail pointer?  */
+  if (!(q2 = opd->key_queue))
+    opd->key_queue = q;
   else
     {
       for (; q2->next; q2 = q2->next)
        ;
       q2->next = q;
     }
-  ctx->key_cond = 1;
-  /* FIXME: Unlock queue.  */
+  opd->key_cond = 1;
 }
 
 
-/**
- * gpgme_op_keylist_start:
- * @c: context 
- * @pattern: a GnuPG user ID or NULL for all
- * @secret_only: List only keys where the secret part is available
- * 
- * Note that this function also cancels a pending key listing
- * operaton. To actually retrieve the key, use
- * gpgme_op_keylist_next().
- * 
- * Return value:  0 on success or an errorcode. 
- **/
-GpgmeError
-gpgme_op_keylist_start (GpgmeCtx ctx, const char *pattern, int secret_only)
+/* Start a keylist operation within CTX, searching for keys which
+   match PATTERN.  If SECRET_ONLY is true, only secret keys are
+   returned.  */
+gpgme_error_t
+gpgme_op_keylist_start (gpgme_ctx_t ctx, const char *pattern, int secret_only)
 {
-  GpgmeError err = 0;
+  gpgme_error_t err;
+  void *hook;
+  op_data_t opd;
 
   err = _gpgme_op_reset (ctx, 2);
   if (err)
-    goto leave;
+    return err;
 
-  gpgme_key_release (ctx->tmp_key);
-  ctx->tmp_key = NULL;
-  /* Fixme: Release key_queue.  */
+  err = _gpgme_op_data_lookup (ctx, OPDATA_KEYLIST, &hook,
+                              sizeof (*opd), release_op_data);
+  opd = hook;
+  if (err)
+    return err;
 
   _gpgme_engine_set_status_handler (ctx->engine, keylist_status_handler, ctx);
+
   err = _gpgme_engine_set_colon_line_handler (ctx->engine,
                                              keylist_colon_handler, ctx);
   if (err)
-    goto leave;
-
-  /* We don't want to use the verbose mode as this will also print the
-     key signatures which is in most cases not needed and furthermore
-     we just ignore those lines - This should speed up things.  */
-  _gpgme_engine_set_verbosity (ctx->engine, 0);
-
-  err = _gpgme_engine_op_keylist (ctx->engine, pattern, secret_only,
-                                 ctx->keylist_mode);
+    return err;
 
-  if (!err)    /* And kick off the process.  */
-    err = _gpgme_engine_start (ctx->engine, ctx);
-
- leave:
-  if (err)
-    {
-      ctx->pending = 0; 
-      _gpgme_engine_release (ctx->engine);
-      ctx->engine = NULL;
-    }
-  return err;
+  return _gpgme_engine_op_keylist (ctx->engine, pattern, secret_only,
+                                  ctx->keylist_mode);
 }
 
 
-/**
- * gpgme_op_keylist_ext_start:
- * @c: context 
- * @pattern: a NULL terminated array of search patterns
- * @secret_only: List only keys where the secret part is available
- * @reserved: Should be 0.
- * 
- * Note that this function also cancels a pending key listing
- * operaton. To actually retrieve the key, use
- * gpgme_op_keylist_next().
- * 
- * Return value:  0 on success or an errorcode. 
- **/
-GpgmeError
-gpgme_op_keylist_ext_start (GpgmeCtx ctx, const char *pattern[],
+/* Start a keylist operation within CTX, searching for keys which
+   match PATTERN.  If SECRET_ONLY is true, only secret keys are
+   returned.  */
+gpgme_error_t
+gpgme_op_keylist_ext_start (gpgme_ctx_t ctx, const char *pattern[],
                            int secret_only, int reserved)
 {
-  GpgmeError err = 0;
+  gpgme_error_t err;
+  void *hook;
+  op_data_t opd;
 
   err = _gpgme_op_reset (ctx, 2);
   if (err)
-    goto leave;
+    return err;
 
-  gpgme_key_release (ctx->tmp_key);
-  ctx->tmp_key = NULL;
+  err = _gpgme_op_data_lookup (ctx, OPDATA_KEYLIST, &hook,
+                              sizeof (*opd), release_op_data);
+  opd = hook;
+  if (err)
+    return err;
 
   _gpgme_engine_set_status_handler (ctx->engine, keylist_status_handler, ctx);
   err = _gpgme_engine_set_colon_line_handler (ctx->engine,
                                              keylist_colon_handler, ctx);
   if (err)
-    goto leave;
-
-  /* We don't want to use the verbose mode as this will also print the
-     key signatures which is in most cases not needed and furthermore
-     we just ignore those lines - This should speed up things.  */
-  _gpgme_engine_set_verbosity (ctx->engine, 0);
+    return err;
 
-  err = _gpgme_engine_op_keylist_ext (ctx->engine, pattern, secret_only,
-                                     reserved, ctx->keylist_mode);
-
-  /* And kick off the process.  */
-  if (!err)
-    err = _gpgme_engine_start (ctx->engine, ctx);
-
- leave:
-  if (err)
-    {
-      ctx->pending = 0; 
-      _gpgme_engine_release (ctx->engine);
-      ctx->engine = NULL;
-    }
-  return err;
+  return _gpgme_engine_op_keylist_ext (ctx->engine, pattern, secret_only,
+                                      reserved, ctx->keylist_mode);
 }
 
 
-/**
- * gpgme_op_keylist_next:
- * @c: Context
- * @r_key: Returned key object
- * 
- * Return the next key from the key listing started with
- * gpgme_op_keylist_start().  The caller must free the key using
- * gpgme_key_release().  If the last key has already been returned the
- * last time the function was called, %GPGME_EOF is returned and the
- * operation is finished.
- * 
- * Return value: 0 on success, %GPGME_EOF or another error code.
- **/
-GpgmeError
-gpgme_op_keylist_next (GpgmeCtx ctx, GpgmeKey *r_key)
+/* Return the next key from the keylist in R_KEY.  */
+gpgme_error_t
+gpgme_op_keylist_next (gpgme_ctx_t ctx, gpgme_key_t *r_key)
 {
+  gpgme_error_t err;
   struct key_queue_item_s *queue_item;
+  void *hook;
+  op_data_t opd;
 
-  if (!r_key)
-    return mk_error (Invalid_Value);
+  if (!ctx || !r_key)
+    return gpg_error (GPG_ERR_INV_VALUE);
   *r_key = NULL;
   if (!ctx)
-    return mk_error (Invalid_Value);
-  if (!ctx->pending)
-    return mk_error (No_Request);
-  if (ctx->error)
-    return ctx->error;
+    return gpg_error (GPG_ERR_INV_VALUE);
 
-  if (!ctx->key_queue)
+  err = _gpgme_op_data_lookup (ctx, OPDATA_KEYLIST, &hook, -1, NULL);
+  opd = hook;
+  if (err)
+    return err;
+  if (opd == NULL)
+    return gpg_error (GPG_ERR_INV_VALUE);
+
+  if (!opd->key_queue)
     {
-      GpgmeError err = _gpgme_wait_on_condition (ctx, &ctx->key_cond);
+      err = _gpgme_wait_on_condition (ctx, &opd->key_cond);
       if (err)
-       {
-         ctx->pending = 0;
-         return err;
-       }
-      if (!ctx->pending)
-       {
-         /* The operation finished.  Because not all keys might have
-            been returned to the caller yet, we just reset the
-            pending flag to 1.  This will cause us to call
-            _gpgme_wait_on_condition without any active file
-            descriptors, but that is a no-op, so it is safe.  */
-         ctx->pending = 1;
-       }
-      if (!ctx->key_cond)
-       {
-         ctx->pending = 0;
-         return mk_error (EOF);
-       }
-      ctx->key_cond = 0; 
-      assert (ctx->key_queue);
+       return err;
+
+      if (!opd->key_cond)
+       return gpg_error (GPG_ERR_EOF);
+
+      opd->key_cond = 0; 
+      assert (opd->key_queue);
     }
-  queue_item = ctx->key_queue;
-  ctx->key_queue = queue_item->next;
-  if (!ctx->key_queue)
-    ctx->key_cond = 0;
+  queue_item = opd->key_queue;
+  opd->key_queue = queue_item->next;
+  if (!opd->key_queue)
+    opd->key_cond = 0;
   
   *r_key = queue_item->key;
   free (queue_item);
@@ -893,23 +909,72 @@ gpgme_op_keylist_next (GpgmeCtx ctx, GpgmeKey *r_key)
 }
 
 
-/**
- * gpgme_op_keylist_end:
- * @c: Context
- * 
- * Ends the keylist operation and allows to use the context for some
- * other operation next.
- **/
-GpgmeError
-gpgme_op_keylist_end (GpgmeCtx ctx)
+/* Terminate a pending keylist operation within CTX.  */
+gpgme_error_t
+gpgme_op_keylist_end (gpgme_ctx_t ctx)
 {
   if (!ctx)
-    return mk_error (Invalid_Value);
-  if (!ctx->pending)
-    return mk_error (No_Request);
-  if (ctx->error)
-    return ctx->error;
+    return gpg_error (GPG_ERR_INV_VALUE);
 
-  ctx->pending = 0;
   return 0;
 }
+
+\f
+/* Get the key with the fingerprint FPR from the crypto backend.  If
+   SECRET is true, get the secret key.  */
+gpgme_error_t
+gpgme_get_key (gpgme_ctx_t ctx, const char *fpr, gpgme_key_t *r_key,
+              int secret)
+{
+  gpgme_ctx_t listctx;
+  gpgme_error_t err;
+  gpgme_key_t key;
+
+  if (!ctx || !r_key || !fpr)
+    return gpg_error (GPG_ERR_INV_VALUE);
+  
+  if (strlen (fpr) < 8)        /* We have at least a key ID.  */
+    return gpg_error (GPG_ERR_INV_VALUE);
+
+  /* FIXME: We use our own context because we have to avoid the user's
+     I/O callback handlers.  */
+  err = gpgme_new (&listctx);
+  if (err)
+    return err;
+  {
+    gpgme_protocol_t proto;
+    gpgme_engine_info_t info;
+
+    /* Clone the relevant state.  */
+    proto = gpgme_get_protocol (ctx);
+    gpgme_set_protocol (listctx, proto);
+    gpgme_set_keylist_mode (listctx, gpgme_get_keylist_mode (ctx));
+    info = gpgme_ctx_get_engine_info (ctx);
+    while (info && info->protocol != proto)
+      info = info->next;
+    if (info)
+      gpgme_ctx_set_engine_info (listctx, proto,
+                                info->file_name, info->home_dir);
+  }
+
+  err = gpgme_op_keylist_start (listctx, fpr, secret);
+  if (!err)
+    err = gpgme_op_keylist_next (listctx, r_key);
+  if (!err)
+    {
+      err = gpgme_op_keylist_next (listctx, &key);
+      if (gpgme_err_code (err) == GPG_ERR_EOF)
+       err = gpg_error (GPG_ERR_NO_ERROR);
+      else
+       {
+         if (!err)
+           {
+             gpgme_key_unref (key);
+             err = gpg_error (GPG_ERR_AMBIGUOUS_NAME);
+           }
+         gpgme_key_unref (*r_key);
+       }
+    }
+  gpgme_release (listctx);
+  return err;
+}