diff --git a/common/userids.c b/common/userids.c
index 55bd85546..eb714a9af 100644
--- a/common/userids.c
+++ b/common/userids.c
@@ -1,475 +1,489 @@
 /* userids.c - Utility functions for user ids.
  * Copyright (C) 2001, 2003, 2004, 2006,
  *               2009 Free Software Foundation, Inc.
  * Copyright (C) 2015  g10 Code GmbH
  *
  * This file is part of GnuPG.
  *
  * This file is free software; you can redistribute it and/or modify
  * it under the terms of either
  *
  *   - the GNU Lesser General Public License as published by the Free
  *     Software Foundation; either version 3 of the License, or (at
  *     your option) any later version.
  *
  * or
  *
  *   - 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.
  *
  * or both in parallel, as here.
  *
  * This file 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 this program; if not, see <https://www.gnu.org/licenses/>.
  */
 
 #include <config.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include "util.h"
 #include "userids.h"
 
 
 /* Parse the user-id NAME and build a search description for it.
  * Returns 0 on success or an error code.  DESC may be NULL to merely
  * check the validity of a user-id.
  *
  * Some used rules:
  * - If the username starts with 8,9,16 or 17 hex-digits (the first one
  *   must be in the range 0..9), this is considered a keyid; depending
  *   on the length a short or complete one.
  * - If the username starts with 32,33,40 or 41 hex-digits (the first one
  *   must be in the range 0..9), this is considered a fingerprint.
  * - If the username starts with a left angle, we assume it is a complete
  *   email address and look only at this part.
  * - If the username starts with a colon we assume it is a unified
  *   key specfification.
  * - If the username starts with a '.', we assume it is the ending
  *   part of an email address
  * - If the username starts with an '@', we assume it is a part of an
  *   email address
  * - If the userid start with an '=' an exact compare is done.
  * - If the userid starts with a '*' a case insensitive substring search is
  *   done (This is the default).
  * - If the userid starts with a '+' we will compare individual words
  *   and a match requires that all the words are in the userid.
  *   Words are delimited by white space or "()<>[]{}.@-+_,;/&!"
  *   (note that you can't search for these characters). Compare
  *   is not case sensitive.
  * - If the userid starts with a '&' a 40 hex digits keygrip is expected.
+ * - If the userid starts with a '^' followed by 40 hex digits it describes
+ *   a Unique-Blob-ID (UBID) which is the hash of keyblob or certificate as
+ *   stored in the database.  This is used in the IPC of the keyboxd.
  */
 
 gpg_error_t
 classify_user_id (const char *name, KEYDB_SEARCH_DESC *desc, int openpgp_hack)
 {
   const char *s;
   char *s2 = NULL;
   int rc = 0;
   int hexprefix = 0;
   int hexlength;
   int mode = 0;
   KEYDB_SEARCH_DESC dummy_desc;
 
   if (!desc)
     desc = &dummy_desc;
 
   /* Clear the structure so that the mode field is set to zero unless
      we set it to the correct value right at the end of this
      function. */
   memset (desc, 0, sizeof *desc);
 
   /* Skip leading and trailing spaces.  */
   for(s = name; *s && spacep (s); s++ )
     ;
   if (*s && spacep (s + strlen(s) - 1))
     {
       s2 = xtrystrdup (s);
       if (!s2)
         {
           rc = gpg_error_from_syserror ();
           goto out;
         }
       trim_trailing_spaces (s2);
       s = s2;
     }
 
   switch (*s)
     {
     case 0:  /* Empty string is an error.  */
       rc = gpg_error (GPG_ERR_INV_USER_ID);
       goto out;
 
     case '.': /* An email address, compare from end.  Note that this
                  has not yet been implemented in the search code.  */
       mode = KEYDB_SEARCH_MODE_MAILEND;
       s++;
       desc->u.name = s;
       break;
 
     case '<': /* An email address.  */
       mode = KEYDB_SEARCH_MODE_MAIL;
       /* FIXME: The keyring code in g10 assumes that the mail name is
          prefixed with an '<'.  However the keybox code used for sm/
          assumes it has been removed.  For now we use this simple hack
          to overcome the problem.  */
       if (!openpgp_hack)
         s++;
       desc->u.name = s;
       break;
 
     case '@':  /* Part of an email address.  */
       mode = KEYDB_SEARCH_MODE_MAILSUB;
       s++;
       desc->u.name = s;
       break;
 
     case '=':  /* Exact compare.  */
       mode = KEYDB_SEARCH_MODE_EXACT;
       s++;
       desc->u.name = s;
       break;
 
     case '*':  /* Case insensitive substring search.  */
       mode = KEYDB_SEARCH_MODE_SUBSTR;
       s++;
       desc->u.name = s;
       break;
 
     case '+':  /* Compare individual words.  Note that this has not
                   yet been implemented in the search code.  */
       mode = KEYDB_SEARCH_MODE_WORDS;
       s++;
       desc->u.name = s;
       break;
 
     case '/': /* Subject's DN.  */
       s++;
       if (!*s || spacep (s)) /* No DN or prefixed with a space.  */
         {
           rc = gpg_error (GPG_ERR_INV_USER_ID);
           goto out;
         }
       desc->u.name = s;
       mode = KEYDB_SEARCH_MODE_SUBJECT;
       break;
 
     case '#': /* S/N with optional issuer id or just issuer id.  */
       {
         const char *si;
 
         s++;
         if ( *s == '/')
           { /* "#/" indicates an issuer's DN.  */
             s++;
             if (!*s || spacep (s)) /* No DN or prefixed with a space.  */
               {
                 rc = gpg_error (GPG_ERR_INV_USER_ID);
                 goto out;
               }
             desc->u.name = s;
             mode = KEYDB_SEARCH_MODE_ISSUER;
           }
         else
           { /* Serialnumber + optional issuer ID.  */
             for (si=s; *si && *si != '/'; si++)
               {
                  /* Check for an invalid digit in the serial number. */
                 if (!strchr("01234567890abcdefABCDEF", *si))
                   {
                     rc = gpg_error (GPG_ERR_INV_USER_ID);
                     goto out;
                   }
               }
             desc->sn = (const unsigned char*)s;
             desc->snlen = -1;
             if (!*si)
               mode = KEYDB_SEARCH_MODE_SN;
             else
               {
                 s = si+1;
                 if (!*s || spacep (s))  /* No DN or prefixed with a space.  */
                   {
                     rc = gpg_error (GPG_ERR_INV_USER_ID);
                     goto out;
                   }
                 desc->u.name = s;
                 mode = KEYDB_SEARCH_MODE_ISSUER_SN;
               }
           }
       }
       break;
 
     case ':': /* Unified fingerprint. */
       {
         const char *se, *si;
         int i;
 
         se = strchr (++s,':');
         if (!se)
           {
             rc = gpg_error (GPG_ERR_INV_USER_ID);
             goto out;
           }
         for (i=0,si=s; si < se; si++, i++ )
           {
             if (!strchr("01234567890abcdefABCDEF", *si))
               {
                 rc = gpg_error (GPG_ERR_INV_USER_ID); /* Invalid digit.  */
                 goto out;
               }
           }
         if (i != 32 && i != 40 && i != 64)
           {
             rc = gpg_error (GPG_ERR_INV_USER_ID); /* Invalid length of fpr.  */
             goto out;
           }
         for (i=0,si=s; si < se; i++, si +=2)
           desc->u.fpr[i] = hextobyte(si);
         desc->fprlen = i;
         for (; i < 32; i++)
           desc->u.fpr[i]= 0;
         mode = KEYDB_SEARCH_MODE_FPR;
       }
       break;
 
     case '&': /* Keygrip*/
       {
         if (hex2bin (s+1, desc->u.grip, 20) < 0)
           {
             rc = gpg_error (GPG_ERR_INV_USER_ID); /* Invalid. */
             goto out;
           }
         mode = KEYDB_SEARCH_MODE_KEYGRIP;
       }
       break;
 
+    case '^': /* UBID */
+      {
+        if (hex2bin (s+1, desc->u.ubid, 20) < 0)
+          {
+            rc = gpg_error (GPG_ERR_INV_USER_ID); /* Invalid. */
+            goto out;
+          }
+        mode = KEYDB_SEARCH_MODE_UBID;
+      }
+      break;
+
     default:
       if (s[0] == '0' && s[1] == 'x')
         {
           hexprefix = 1;
           s += 2;
         }
 
       hexlength = strspn(s, "0123456789abcdefABCDEF");
       if (hexlength >= 8 && s[hexlength] =='!')
         {
           desc->exact = 1;
           hexlength++; /* Just for the following check.  */
         }
 
       /* Check if a hexadecimal number is terminated by EOS or blank.  */
       if (hexlength && s[hexlength] && !spacep (s+hexlength))
         {
           if (hexprefix) /* A "0x" prefix without a correct
                             termination is an error.  */
             {
               rc = gpg_error (GPG_ERR_INV_USER_ID);
               goto out;
             }
           /* The first characters looked like a hex number, but the
              entire string is not.  */
           hexlength = 0;
         }
 
       if (desc->exact)
         hexlength--; /* Remove the bang.  */
 
       if ((hexlength == 8
            && (s[hexlength] == 0
                || (s[hexlength] == '!' && s[hexlength + 1] == 0)))
           || (!hexprefix && hexlength == 9 && *s == '0'))
         {
           /* Short keyid.  */
           if (hexlength == 9)
             s++;
           desc->u.kid[1] = strtoul( s, NULL, 16 );
           mode = KEYDB_SEARCH_MODE_SHORT_KID;
         }
       else if ((hexlength == 16
                 && (s[hexlength] == 0
                     || (s[hexlength] == '!' && s[hexlength + 1] == 0)))
                || (!hexprefix && hexlength == 17 && *s == '0'))
         {
           /* Long keyid.  */
           char buf[9];
           if (hexlength == 17)
             s++;
           mem2str (buf, s, 9);
           desc->u.kid[0] = strtoul (buf, NULL, 16);
           desc->u.kid[1] = strtoul (s+8, NULL, 16);
           mode = KEYDB_SEARCH_MODE_LONG_KID;
         }
       else if ((hexlength == 32
                 && (s[hexlength] == 0
                     || (s[hexlength] == '!' && s[hexlength + 1] == 0)))
                || (!hexprefix && hexlength == 33 && *s == '0'))
         {
           /* MD5 fingerprint.  */
           int i;
           if (hexlength == 33)
             s++;
           memset (desc->u.fpr+16, 0, 4);
           for (i=0; i < 16; i++, s+=2)
             {
               int c = hextobyte(s);
               if (c == -1)
                 {
                   rc = gpg_error (GPG_ERR_INV_USER_ID);
                   goto out;
                 }
               desc->u.fpr[i] = c;
             }
           desc->fprlen = 16;
           for (; i < 32; i++)
             desc->u.fpr[i]= 0;
           mode = KEYDB_SEARCH_MODE_FPR;
         }
       else if ((hexlength == 40
                 && (s[hexlength] == 0
                     || (s[hexlength] == '!' && s[hexlength + 1] == 0)))
                || (!hexprefix && hexlength == 41 && *s == '0'))
         {
           /* SHA1 fingerprint.  */
           int i;
           if (hexlength == 41)
             s++;
           for (i=0; i < 20; i++, s+=2)
             {
               int c = hextobyte(s);
               if (c == -1)
                 {
                   rc = gpg_error (GPG_ERR_INV_USER_ID);
                   goto out;
                 }
               desc->u.fpr[i] = c;
             }
           desc->fprlen = 20;
           for (; i < 32; i++)
             desc->u.fpr[i]= 0;
           mode = KEYDB_SEARCH_MODE_FPR;
         }
       else if ((hexlength == 64
                 && (s[hexlength] == 0
                     || (s[hexlength] == '!' && s[hexlength + 1] == 0)))
                || (!hexprefix && hexlength == 65 && *s == '0'))
         {
           /* SHA256 fingerprint.  */
           int i;
           if (hexlength == 65)
             s++;
           for (i=0; i < 32; i++, s+=2)
             {
               int c = hextobyte(s);
               if (c == -1)
                 {
                   rc = gpg_error (GPG_ERR_INV_USER_ID);
                   goto out;
                 }
               desc->u.fpr[i] = c;
             }
           desc->fprlen = 32;
           mode = KEYDB_SEARCH_MODE_FPR;
         }
       else if (!hexprefix)
         {
           /* The fingerprint of an X.509 listing is often delimited by
            * colons, so we try to single this case out.  Note that the
            * OpenPGP bang suffix is not supported here.  */
           desc->exact = 0;
           mode = 0;
           hexlength = strspn (s, ":0123456789abcdefABCDEF");
           if (hexlength == 59 && (!s[hexlength] || spacep (s+hexlength)))
             {
               int i;
 
               for (i=0; i < 20; i++, s += 3)
                 {
                   int c = hextobyte(s);
                   if (c == -1 || (i < 19 && s[2] != ':'))
                     break;
                   desc->u.fpr[i] = c;
                 }
               if (i == 20)
                 {
                   desc->fprlen = 20;
                   mode = KEYDB_SEARCH_MODE_FPR;
                 }
               for (; i < 32; i++)
                 desc->u.fpr[i]= 0;
             }
           if (!mode)
             {
               /* Still not found.  Now check for a space separated
                * OpenPGP v4 fingerprint like:
                *   8061 5870 F5BA D690 3336  86D0 F2AD 85AC 1E42 B367
                * or
                *   8061 5870 F5BA D690 3336 86D0 F2AD 85AC 1E42 B367
                * FIXME: Support OpenPGP v5 fingerprint
                */
               hexlength = strspn (s, " 0123456789abcdefABCDEF");
               if (s[hexlength] && s[hexlength] != ' ')
                 hexlength = 0; /* Followed by non-space.  */
               while (hexlength && s[hexlength-1] == ' ')
                 hexlength--;   /* Trim trailing spaces.  */
               if ((hexlength == 49 || hexlength == 50)
                   && (!s[hexlength] || s[hexlength] == ' '))
                 {
                   int i, c;
 
                   for (i=0; i < 20; i++)
                     {
                       if (i && !(i % 2))
                         {
                           if (*s != ' ')
                             break;
                           s++;
                           /* Skip the double space in the middle but
                              don't require it to help copying
                              fingerprints from sources which fold
                              multiple space to one.  */
                           if (i == 10 && *s == ' ')
                             s++;
                         }
 
                       c = hextobyte(s);
                       if (c == -1)
                         break;
                       desc->u.fpr[i] = c;
                       s += 2;
                     }
                   if (i == 20)
                     {
                       desc->fprlen = 20;
                       mode = KEYDB_SEARCH_MODE_FPR;
                     }
                   for (; i < 32; i++)
                     desc->u.fpr[i]= 0;
                 }
             }
           if (!mode) /* Default to substring search.  */
             {
               desc->u.name = s;
               mode = KEYDB_SEARCH_MODE_SUBSTR;
             }
         }
       else
 	{
           /* Hex number with a prefix but with a wrong length.  */
           rc = gpg_error (GPG_ERR_INV_USER_ID);
           goto out;
         }
     }
 
   desc->mode = mode;
  out:
   xfree (s2);
   return rc;
 }
diff --git a/doc/DETAILS b/doc/DETAILS
index ed5cadec6..0610108f4 100644
--- a/doc/DETAILS
+++ b/doc/DETAILS
@@ -1,1592 +1,1593 @@
 # doc/DETAILS                                                -*- org -*-
 #+TITLE: GnuPG Details
 # Globally disable superscripts and subscripts:
 #+OPTIONS: ^:{}
 #
 
 # Note: This file uses org-mode; it should be easy to read as plain
 # text but be aware of some markup peculiarities: Verbatim code is
 # enclosed in #+begin-example, #+end-example blocks or marked by a
 # colon as the first non-white-space character, words bracketed with
 # equal signs indicate a monospace font, and the usual /italics/,
 # *bold*, and _underline_ conventions are recognized.
 
 This is the DETAILS file for GnuPG which specifies some internals and
 parts of the external API for GPG and GPGSM.
 
 * Format of the colon listings
 
   The format is a based on colon separated record, each recods starts
   with a tag string and extends to the end of the line.  Here is an
   example:
 #+begin_example
 $ gpg --with-colons --list-keys \
       --with-fingerprint --with-fingerprint wk@gnupg.org
 pub:f:1024:17:6C7EE1B8621CC013:899817715:1055898235::m:::scESC:
 fpr:::::::::ECAF7590EB3443B5C7CF3ACB6C7EE1B8621CC013:
 uid:f::::::::Werner Koch <wk@g10code.com>:
 uid:f::::::::Werner Koch <wk@gnupg.org>:
 sub:f:1536:16:06AD222CADF6A6E1:919537416:1036177416:::::e:
 fpr:::::::::CF8BCC4B18DE08FCD8A1615906AD222CADF6A6E1:
 sub:r:1536:20:5CE086B5B5A18FF4:899817788:1025961788:::::esc:
 fpr:::::::::AB059359A3B81F410FCFF97F5CE086B5B5A18FF4:
 #+end_example
 
 Note that new version of GnuPG or the use of certain options may add
 new fields to the output.  Parsers should not assume a limit on the
 number of fields per line.  Some fields are not yet used or only used
 with certain record types; parsers should ignore fields they are not
 aware of.  New versions of GnuPG or the use of certain options may add
 new types of records as well.  Parsers should ignore any record whose
 type they do not recognize for forward-compatibility.
 
 The double =--with-fingerprint= prints the fingerprint for the subkeys
 too.  Old versions of gpg used a slightly different format and required
 the use of the option =--fixed-list-mode= to conform to the format
 described here.
 
 
 ** Description of the fields
 *** Field 1 - Type of record
 
     - pub :: Public key
     - crt :: X.509 certificate
     - crs :: X.509 certificate and private key available
     - sub :: Subkey (secondary key)
     - sec :: Secret key
     - ssb :: Secret subkey (secondary key)
     - uid :: User id
     - uat :: User attribute (same as user id except for field 10).
     - sig :: Signature
     - rev :: Revocation signature
     - rvs :: Revocation signature (standalone) [since 2.2.9]
     - fpr :: Fingerprint (fingerprint is in field 10)
     - pkd :: Public key data [*]
     - grp :: Keygrip
     - rvk :: Revocation key
     - tfs :: TOFU statistics [*]
     - tru :: Trust database information [*]
     - spk :: Signature subpacket [*]
     - cfg :: Configuration data [*]
 
     Records marked with an asterisk are described at [[*Special%20field%20formats][*Special fields]].
 
 *** Field 2 - Validity
 
     This is a letter describing the computed validity of a key.
     Currently this is a single letter, but be prepared that additional
     information may follow in some future versions. Note that GnuPG <
     2.1 does not set this field for secret key listings.
 
     - o :: Unknown (this key is new to the system)
     - i :: The key is invalid (e.g. due to a missing self-signature)
     - d :: The key has been disabled
 	   (deprecated - use the 'D' in field 12 instead)
     - r :: The key has been revoked
     - e :: The key has expired
     - - :: Unknown validity (i.e. no value assigned)
     - q :: Undefined validity.  '-' and 'q' may safely be treated as
            the same value for most purposes
     - n :: The key is not valid
     - m :: The key is marginal valid.
     - f :: The key is fully valid
     - u :: The key is ultimately valid.  This often means that the
            secret key is available, but any key may be marked as
            ultimately valid.
     - w :: The key has a well known private part.
     - s :: The key has special validity.  This means that it might be
            self-signed and expected to be used in the STEED system.
 
     If the validity information is given for a UID or UAT record, it
     describes the validity calculated based on this user ID.  If given
     for a key record it describes the validity taken from the best
     rated user ID.
 
     For X.509 certificates a 'u' is used for a trusted root
     certificate (i.e. for the trust anchor) and an 'f' for all other
     valid certificates.
 
     In "sig" records, this field may have one of these values as first
     character:
 
     - ! :: Signature is good.
     - - :: Signature is bad.
     - ? :: No public key to verify signature or public key is not usable.
     - % :: Other error verifying a signature
 
     More values may be added later.  The field may also be empty if
     gpg has been invoked in a non-checking mode (--list-sigs) or in a
     fast checking mode.  Since 2.2.7 '?' will also be printed by the
     command --list-sigs if the key is not in the local keyring.
 
 *** Field 3 - Key length
 
     The length of key in bits.
 
 *** Field 4 - Public key algorithm
 
     The values here are those from the OpenPGP specs or if they are
     greater than 255 the algorithm ids as used by Libgcrypt.
 
 *** Field 5 - KeyID
 
     This is the 64 bit keyid as specified by OpenPGP and the last 64
     bit of the SHA-1 fingerprint of an X.509 certifciate.
 
 *** Field 6 - Creation date
 
     The creation date of the key is given in UTC.  For UID and UAT
     records, this is used for the self-signature date.  Note that the
     date is usually printed in seconds since epoch, however, we are
     migrating to an ISO 8601 format (e.g. "19660205T091500").  This is
     currently only relevant for X.509.  A simple way to detect the new
     format is to scan for the 'T'.  Note that old versions of gpg
     without using the =--fixed-list-mode= option used a "yyyy-mm-tt"
     format.
 
 *** Field 7 - Expiration date
 
     Key or UID/UAT expiration date or empty if it does not expire.
 
 *** Field 8 - Certificate S/N, UID hash, trust signature info
 
     Used for serial number in crt records.  For UID and UAT records,
     this is a hash of the user ID contents used to represent that
     exact user ID.  For trust signatures, this is the trust depth
     separated by the trust value by a space.
 
 *** Field 9 -  Ownertrust
 
     This is only used on primary keys.  This is a single letter, but
     be prepared that additional information may follow in future
     versions.  For trust signatures with a regular expression, this is
     the regular expression value, quoted as in field 10.
 
 *** Field 10 - User-ID
 
     The value is quoted like a C string to avoid control characters
     (the colon is quoted =\x3a=).  For a "pub" record this field is
     not used on --fixed-list-mode.  A UAT record puts the attribute
     subpacket count here, a space, and then the total attribute
     subpacket size.  In gpgsm the issuer name comes here.  A FPR
     record stores the fingerprint here.  The fingerprint of a
     revocation key is stored here.
 
 *** Field 11 - Signature class
 
     Signature class as per RFC-4880.  This is a 2 digit hexnumber
     followed by either the letter 'x' for an exportable signature or
     the letter 'l' for a local-only signature.  The class byte of an
     revocation key is also given here, 'x' and 'l' is used the same
     way.  This field if not used for X.509.
 
     "rev" and "rvs" may be followed by a comma and a 2 digit hexnumber
     with the revocation reason.
 
 *** Field 12 - Key capabilities
 
     The defined capabilities are:
 
     - e :: Encrypt
     - s :: Sign
     - c :: Certify
     - a :: Authentication
     - ? :: Unknown capability
 
     A key may have any combination of them in any order.  In addition
     to these letters, the primary key has uppercase versions of the
     letters to denote the _usable_ capabilities of the entire key, and
     a potential letter 'D' to indicate a disabled key.
 
 *** Field 13 - Issuer certificate fingerprint or other info
 
     Used in FPR records for S/MIME keys to store the fingerprint of
     the issuer certificate.  This is useful to build the certificate
     path based on certificates stored in the local key database it is
     only filled if the issuer certificate is available. The root has
     been reached if this is the same string as the fingerprint. The
     advantage of using this value is that it is guaranteed to have
     been built by the same lookup algorithm as gpgsm uses.
 
     For "uid" records this field lists the preferences in the same way
     gpg's --edit-key menu does.
 
     For "sig", "rev" and "rvs" records, this is the fingerprint of the
     key that issued the signature.  Note that this may only be filled
     if the signature verified correctly.  Note also that for various
     technical reasons, this fingerprint is only available if
     --no-sig-cache is used.  Since 2.2.7 this field will also be set
     if the key is missing but the signature carries an issuer
     fingerprint as meta data.
 
 *** Field 14 - Flag field
 
     Flag field used in the --edit menu output
 
 *** Field 15 - S/N of a token
 
     Used in sec/ssb to print the serial number of a token (internal
     protect mode 1002) or a '#' if that key is a simple stub (internal
     protect mode 1001).  If the option --with-secret is used and a
     secret key is available for the public key, a '+' indicates this.
 
 *** Field 16 - Hash algorithm
 
     For sig records, this is the used hash algorithm.  For example:
     2 = SHA-1, 8 = SHA-256.
 
 *** Field 17 - Curve name
 
     For pub, sub, sec, and ssb records this field is used for the ECC
     curve name.
 
 *** Field 18 - Compliance flags
 
     Space separated list of asserted compliance modes and
     screening result for this key.
 
     Valid values are:
 
     - 8  :: The key is compliant with RFC4880bis
     - 23 :: The key is compliant with compliance mode "de-vs".
     - 6001 :: Screening hit on the ROCA vulnerability.
 
 *** Field 19 - Last update
 
     The timestamp of the last update of a key or user ID.  The update
     time of a key is defined a lookup of the key via its unique
     identifier (fingerprint); the field is empty if not known.  The
     update time of a user ID is defined by a lookup of the key using a
     trusted mapping from mail address to key.
 
 *** Field 20 - Origin
 
     The origin of the key or the user ID.  This is an integer
     optionally followed by a space and an URL.  This goes along with
     the previous field.  The URL is quoted in C style.
 
 *** Field 21 - Comment
 
     This is currently only used in "rev" and "rvs" records to carry
     the the comment field of the recocation reason.  The value is
     quoted in C style.
 
 ** Special fields
 
 *** PKD - Public key data
 
     If field 1 has the tag "pkd", a listing looks like this:
 #+begin_example
 pkd:0:1024:B665B1435F4C2 .... FF26ABB:
     !  !   !-- the value
     !  !------ for information number of bits in the value
     !--------- index (eg. DSA goes from 0 to 3: p,q,g,y)
 #+end_example
 
 *** TFS - TOFU statistics
 
     This field may follows a UID record to convey information about
     the TOFU database.  The information is similar to a TOFU_STATS
     status line.
 
     - Field 2 :: tfs record version (must be 1)
     - Field 3 :: validity -  A number with validity code.
     - Field 4 :: signcount - The number of signatures seen.
     - Field 5 :: encrcount - The number of encryptions done.
     - Field 6 :: policy - A string with the policy
     - Field 7 :: signture-first-seen - a timestamp or 0 if not known.
     - Field 8 :: signature-most-recent-seen - a timestamp or 0 if not known.
     - Field 9 :: encryption-first-done - a timestamp or 0 if not known.
     - Field 10 :: encryption-most-recent-done - a timestamp or 0 if not known.
 
 *** TRU - Trust database information
     Example for a "tru" trust base record:
 #+begin_example
     tru:o:0:1166697654:1:3:1:5
 #+end_example
 
     - Field 2 :: Reason for staleness of trust.  If this field is
                  empty, then the trustdb is not stale.  This field may
                  have multiple flags in it:
 
                  - o :: Trustdb is old
                  - t :: Trustdb was built with a different trust model
                         than the one we are using now.
 
     - Field 3 :: Trust model
 
                  - 0 :: Classic trust model, as used in PGP 2.x.
                  - 1 :: PGP trust model, as used in PGP 6 and later.
                         This is the same as the classic trust model,
                         except for the addition of trust signatures.
 
                  GnuPG before version 1.4 used the classic trust model
                  by default. GnuPG 1.4 and later uses the PGP trust
                  model by default.
 
     - Field 4 :: Date trustdb was created in seconds since Epoch.
     - Field 5 :: Date trustdb will expire in seconds since Epoch.
     - Field 6 :: Number of marginally trusted users to introduce a new
                  key signer (gpg's option --marginals-needed).
     - Field 7 :: Number of completely trusted users to introduce a new
                  key signer.  (gpg's option --completes-needed)
 
     - Field 8 :: Maximum depth of a certification chain. (gpg's option
                  --max-cert-depth)
 
 *** SPK - Signature subpacket records
 
     - Field 2 :: Subpacket number as per RFC-4880 and later.
     - Field 3 :: Flags in hex.  Currently the only two bits assigned
                  are 1, to indicate that the subpacket came from the
                  hashed part of the signature, and 2, to indicate the
                  subpacket was marked critical.
     - Field 4 :: Length of the subpacket.  Note that this is the
                  length of the subpacket, and not the length of field
                  5 below.  Due to the need for %-encoding, the length
                  of field 5 may be up to 3x this value.
     - Field 5 :: The subpacket data.  Printable ASCII is shown as
                  ASCII, but other values are rendered as %XX where XX
                  is the hex value for the byte.
 
 *** CFG - Configuration data
 
     --list-config outputs information about the GnuPG configuration
     for the benefit of frontends or other programs that call GnuPG.
     There are several list-config items, all colon delimited like the
     rest of the --with-colons output.  The first field is always "cfg"
     to indicate configuration information.  The second field is one of
     (with examples):
 
     - version :: The third field contains the version of GnuPG.
 
                  : cfg:version:1.3.5
 
     - pubkey :: The third field contains the public key algorithms
                 this version of GnuPG supports, separated by
                 semicolons.  The algorithm numbers are as specified in
                 RFC-4880.  Note that in contrast to the --status-fd
                 interface these are _not_ the Libgcrypt identifiers.
                 Using =pubkeyname= prints names instead of numbers.
 
                  : cfg:pubkey:1;2;3;16;17
 
     - cipher :: The third field contains the symmetric ciphers this
                 version of GnuPG supports, separated by semicolons.
                 The cipher numbers are as specified in RFC-4880.
                 Using =ciphername= prints names instead of numbers.
 
                  : cfg:cipher:2;3;4;7;8;9;10
 
     - digest :: The third field contains the digest (hash) algorithms
                 this version of GnuPG supports, separated by
                 semicolons.  The digest numbers are as specified in
                 RFC-4880.  Using =digestname= prints names instead of
                 numbers.
 
                  : cfg:digest:1;2;3;8;9;10
 
     - compress :: The third field contains the compression algorithms
                   this version of GnuPG supports, separated by
                   semicolons.  The algorithm numbers are as specified
                   in RFC-4880.
 
                  : cfg:compress:0;1;2;3
 
     - group :: The third field contains the name of the group, and the
                fourth field contains the values that the group expands
                to, separated by semicolons.
 
                For example, a group of:
                  : group mynames = paige 0x12345678 joe patti
                would result in:
                  : cfg:group:mynames:patti;joe;0x12345678;paige
 
     - curve :: The third field contains the curve names this version
                of GnuPG supports, separated by semicolons. Using
                =curveoid= prints OIDs instead of numbers.
 
                  : cfg:curve:ed25519;nistp256;nistp384;nistp521
 
 
 * Format of the --status-fd output
 
   Every line is prefixed with "[GNUPG:] ", followed by a keyword with
   the type of the status line and some arguments depending on the type
   (maybe none); an application should always be willing to ignore
   unknown keywords that may be emitted by future versions of GnuPG.
   Also, new versions of GnuPG may add arguments to existing keywords.
   Any additional arguments should be ignored for forward-compatibility.
 
 ** General status codes
 *** NEWSIG [<signers_uid>]
     Is issued right before a signature verification starts.  This is
     useful to define a context for parsing ERROR status messages.
     If SIGNERS_UID is given and is not "-" this is the percent-escaped
     value of the OpenPGP Signer's User ID signature sub-packet.
 
 *** GOODSIG  <long_keyid_or_fpr>  <username>
     The signature with the keyid is good.  For each signature only one
     of the codes GOODSIG, BADSIG, EXPSIG, EXPKEYSIG, REVKEYSIG or
     ERRSIG will be emitted.  In the past they were used as a marker
     for a new signature; new code should use the NEWSIG status
     instead.  The username is the primary one encoded in UTF-8 and %XX
     escaped. The fingerprint may be used instead of the long keyid if
     it is available.  This is the case with CMS and might eventually
     also be available for OpenPGP.
 
 *** EXPSIG  <long_keyid_or_fpr>  <username>
     The signature with the keyid is good, but the signature is
     expired. The username is the primary one encoded in UTF-8 and %XX
     escaped. The fingerprint may be used instead of the long keyid if
     it is available.  This is the case with CMS and might eventually
     also be available for OpenPGP.
 
 *** EXPKEYSIG  <long_keyid_or_fpr> <username>
     The signature with the keyid is good, but the signature was made
     by an expired key. The username is the primary one encoded in
     UTF-8 and %XX escaped.  The fingerprint may be used instead of the
     long keyid if it is available.  This is the case with CMS and
     might eventually also be available for OpenPGP.
 
 *** REVKEYSIG  <long_keyid_or_fpr>  <username>
     The signature with the keyid is good, but the signature was made
     by a revoked key. The username is the primary one encoded in UTF-8
     and %XX escaped. The fingerprint may be used instead of the long
     keyid if it is available.  This is the case with CMS and might
     eventually also beñ available for OpenPGP.
 
 *** BADSIG  <long_keyid_or_fpr>  <username>
     The signature with the keyid has not been verified okay.  The
     username is the primary one encoded in UTF-8 and %XX escaped. The
     fingerprint may be used instead of the long keyid if it is
     available.  This is the case with CMS and might eventually also be
     available for OpenPGP.
 
 *** ERRSIG  <keyid>  <pkalgo> <hashalgo> <sig_class> <time> <rc> <fpr>
     It was not possible to check the signature.  This may be caused by
     a missing public key or an unsupported algorithm.  A RC of 4
     indicates unknown algorithm, a 9 indicates a missing public
     key. The other fields give more information about this signature.
     sig_class is a 2 byte hex-value.  The fingerprint may be used
     instead of the long_keyid_or_fpr if it is available.  This is the
     case with gpgsm and might eventually also be available for
     OpenPGP.  The ERRSIG line has FPR filed which is only available
     since 2.2.7; that FPR may either be missing or - if the signature
     has no fingerprint as meta data.
 
     Note, that TIME may either be the number of seconds since Epoch or
     an ISO 8601 string.  The latter can be detected by the presence of
     the letter 'T'.
 
 *** VALIDSIG <args>
 
     The args are:
 
     - <fingerprint_in_hex>
     - <sig_creation_date>
     - <sig-timestamp>
     - <expire-timestamp>
     - <sig-version>
     - <reserved>
     - <pubkey-algo>
     - <hash-algo>
     - <sig-class>
     - [ <primary-key-fpr> ]
 
     This status indicates that the signature is cryptographically
     valid. This is similar to GOODSIG, EXPSIG, EXPKEYSIG, or REVKEYSIG
     (depending on the date and the state of the signature and signing
     key) but has the fingerprint as the argument. Multiple status
     lines (VALIDSIG and the other appropriate *SIG status) are emitted
     for a valid signature.  All arguments here are on one long line.
     sig-timestamp is the signature creation time in seconds after the
     epoch. expire-timestamp is the signature expiration time in
     seconds after the epoch (zero means "does not
     expire"). sig-version, pubkey-algo, hash-algo, and sig-class (a
     2-byte hex value) are all straight from the signature packet.
     PRIMARY-KEY-FPR is the fingerprint of the primary key or identical
     to the first argument.  This is useful to get back to the primary
     key without running gpg again for this purpose.
 
     The primary-key-fpr parameter is used for OpenPGP and not
     available for CMS signatures.  The sig-version as well as the sig
     class is not defined for CMS and currently set to 0 and 00.
 
     Note, that *-TIMESTAMP may either be a number of seconds since
     Epoch or an ISO 8601 string which can be detected by the presence
     of the letter 'T'.
 
 *** SIG_ID  <radix64_string>  <sig_creation_date>  <sig-timestamp>
     This is emitted only for signatures of class 0 or 1 which have
     been verified okay.  The string is a signature id and may be used
     in applications to detect replay attacks of signed messages.  Note
     that only DLP algorithms give unique ids - others may yield
     duplicated ones when they have been created in the same second.
 
     Note, that SIG-TIMESTAMP may either be a number of seconds since
     Epoch or an ISO 8601 string which can be detected by the presence
     of the letter 'T'.
 
 *** ENC_TO  <long_keyid>  <keytype>  <keylength>
     The message is encrypted to this LONG_KEYID.  KEYTYPE is the
     numerical value of the public key algorithm or 0 if it is not
     known, KEYLENGTH is the length of the key or 0 if it is not known
     (which is currently always the case).  Gpg prints this line
     always; Gpgsm only if it knows the certificate.
 
 *** BEGIN_DECRYPTION
     Mark the start of the actual decryption process.  This is also
     emitted when in --list-only mode.
 *** END_DECRYPTION
     Mark the end of the actual decryption process.  This are also
     emitted when in --list-only mode.
 *** DECRYPTION_KEY <fpr> <fpr2> <otrust>
     This line is emitted when a public key decryption succeeded in
     providing a session key.  <fpr> is the hexified fingerprint of the
     actual key used for decryption.  <fpr2> is the fingerprint of the
     primary key.  <otrust> is the letter with the ownertrust; this is
     in general a 'u' which stands for ultimately trusted.
 *** DECRYPTION_INFO <mdc_method> <sym_algo> [<aead_algo>]
     Print information about the symmetric encryption algorithm and the
     MDC method.  This will be emitted even if the decryption fails.
     For an AEAD algorithm AEAD_ALGO is not 0.  GPGSM currently does
     not print such a status.
 
 *** DECRYPTION_FAILED
     The symmetric decryption failed - one reason could be a wrong
     passphrase for a symmetrical encrypted message.
 
 *** DECRYPTION_OKAY
     The decryption process succeeded.  This means, that either the
     correct secret key has been used or the correct passphrase for a
     symmetric encrypted message was given.  The program itself may
     return an errorcode because it may not be possible to verify a
     signature for some reasons.
 
 *** SESSION_KEY <algo>:<hexdigits>
     The session key used to decrypt the message.  This message will
     only be emitted if the option --show-session-key is used.  The
     format is suitable to be passed as value for the option
     --override-session-key.  It is not an indication that the
     decryption will or has succeeded.
 
 *** BEGIN_ENCRYPTION  <mdc_method> <sym_algo> [<aead_algo>]
     Mark the start of the actual encryption process.
     MDC_METHOD shall be 0 if an AEAD_ALGO is not 0.  Users should
     however ignore MDC_METHOD if AEAD_ALGO is not 0.
 
 *** END_ENCRYPTION
     Mark the end of the actual encryption process.
 
 *** FILE_START <what> <filename>
     Start processing a file <filename>.  <what> indicates the performed
     operation:
     - 1 :: verify
     - 2 :: encrypt
     - 3 :: decrypt
 
 *** FILE_DONE
     Marks the end of a file processing which has been started
     by FILE_START.
 
 *** BEGIN_SIGNING
     Mark the start of the actual signing process. This may be used as
     an indication that all requested secret keys are ready for use.
 
 *** ALREADY_SIGNED <long-keyid>
     Warning: This is experimental and might be removed at any time.
 
 *** SIG_CREATED <type> <pk_algo> <hash_algo> <class> <timestamp> <keyfpr>
     A signature has been created using these parameters.
     Values for type <type> are:
       - D :: detached
       - C :: cleartext
       - S :: standard
     (only the first character should be checked)
 
     <class> are 2 hex digits with the OpenPGP signature class.
 
     Note, that TIMESTAMP may either be a number of seconds since Epoch
     or an ISO 8601 string which can be detected by the presence of the
     letter 'T'.
 
 *** NOTATION_
     There are actually three related status codes to convey notation
     data:
 
     - NOTATION_NAME <name>
     - NOTATION_FLAGS <critical> <human_readable>
     - NOTATION_DATA <string>
 
     <name> and <string> are %XX escaped.  The data may be split among
     several NOTATION_DATA lines.  NOTATION_FLAGS is emitted after
     NOTATION_NAME and gives the critical and human readable flags;
     the flag values are either 0 or 1.
 
 *** POLICY_URL <string>
     Note that URL in <string> is %XX escaped.
 
 *** PLAINTEXT <format> <timestamp> <filename>
     This indicates the format of the plaintext that is about to be
     written.  The format is a 1 byte hex code that shows the format of
     the plaintext: 62 ('b') is binary data, 74 ('t') is text data with
     no character set specified, and 75 ('u') is text data encoded in
     the UTF-8 character set.  The timestamp is in seconds since the
     epoch.  If a filename is available it gets printed as the third
     argument, percent-escaped as usual.
 
 *** PLAINTEXT_LENGTH <length>
     This indicates the length of the plaintext that is about to be
     written.  Note that if the plaintext packet has partial length
     encoding it is not possible to know the length ahead of time.  In
     that case, this status tag does not appear.
 
 *** ATTRIBUTE <arguments>
     The list or arguments are:
     - <fpr>
     - <octets>
     - <type>
     - <index>
     - <count>
     - <timestamp>
     - <expiredate>
     - <flags>
 
     This is one long line issued for each attribute subpacket when an
     attribute packet is seen during key listing.  <fpr> is the
     fingerprint of the key.  <octets> is the length of the attribute
     subpacket.  <type> is the attribute type (e.g. 1 for an image).
     <index> and <count> indicate that this is the N-th indexed
     subpacket of count total subpackets in this attribute packet.
     <timestamp> and <expiredate> are from the self-signature on the
     attribute packet.  If the attribute packet does not have a valid
     self-signature, then the timestamp is 0.  <flags> are a bitwise OR
     of:
     - 0x01 :: this attribute packet is a primary uid
     - 0x02 :: this attribute packet is revoked
     - 0x04 :: this attribute packet is expired
 
 *** SIG_SUBPACKET <type> <flags> <len> <data>
     This indicates that a signature subpacket was seen.  The format is
     the same as the "spk" record above.
 
 *** ENCRYPTION_COMPLIANCE_MODE <flags>
     Indicates that the current encryption operation was in compliance
     with the given set of modes for all recipients.  "flags" is a
     space separated list of numerical flags, see "Field 18 -
     Compliance flags" above.
 
 *** DECRYPTION_COMPLIANCE_MODE <flags>
     Indicates that the current decryption operation is in compliance
     with the given set of modes.  "flags" is a space separated list of
     numerical flags, see "Field 18 - Compliance flags" above.
 
 *** VERIFICATION_COMPLIANCE_MODE <flags>
     Indicates that the current signature verification operation is in
     compliance with the given set of modes.  "flags" is a space
     separated list of numerical flags, see "Field 18 - Compliance
     flags" above.
 
 ** Key related
 *** INV_RECP, INV_SGNR
     The two similar status codes:
 
     - INV_RECP <reason> <requested_recipient>
     - INV_SGNR <reason> <requested_sender>
 
     are issued for each unusable recipient/sender. The reasons codes
     currently in use are:
 
        -  0 :: No specific reason given
        -  1 :: Not Found
        -  2 :: Ambiguous specification
        -  3 :: Wrong key usage
        -  4 :: Key revoked
        -  5 :: Key expired
        -  6 :: No CRL known
        -  7 :: CRL too old
        -  8 :: Policy mismatch
        -  9 :: Not a secret key
        - 10 :: Key not trusted
        - 11 :: Missing certificate
        - 12 :: Missing issuer certificate
        - 13 :: Key disabled
        - 14 :: Syntax error in specification
 
     If no specific reason was given a previously emitted status code
     KEY_CONSIDERED may be used to analyzed the problem.
 
     Note that for historical reasons the INV_RECP status is also used
     for gpgsm's SIGNER command where it relates to signer's of course.
     Newer GnuPG versions are using INV_SGNR; applications should
     ignore the INV_RECP during the sender's command processing once
     they have seen an INV_SGNR.  Different codes are used so that they
     can be distinguish while doing an encrypt+sign operation.
 
 *** NO_RECP <reserved>
     Issued if no recipients are usable.
 
 *** NO_SGNR <reserved>
     Issued if no senders are usable.
 
 *** KEY_CONSIDERED <fpr> <flags>
     Issued to explian the lookup of a key.  FPR is the hexified
     fingerprint of the primary key.  The bit values for FLAGS are:
 
     - 1 :: The key has not been selected.
     - 2 :: All subkeys of the key are expired or have been revoked.
 
 *** KEYEXPIRED <expire-timestamp>
     The key has expired.  expire-timestamp is the expiration time in
     seconds since Epoch.  This status line is not very useful because
     it will also be emitted for expired subkeys even if this subkey is
     not used.  To check whether a key used to sign a message has
     expired, the EXPKEYSIG status line is to be used.
 
     Note, that the TIMESTAMP may either be a number of seconds since
     Epoch or an ISO 8601 string which can be detected by the presence
     of the letter 'T'.
 
 *** KEYREVOKED
     The used key has been revoked by its owner.  No arguments yet.
 
 *** NO_PUBKEY  <long keyid>
     The public key is not available.  Note the arg should in general
     not be used because it is better to take it from the ERRSIG
     status line which is printed right before this one.
 
 *** NO_SECKEY  <long keyid>
     The secret key is not available
 
 *** KEY_CREATED <type> <fingerprint> [<handle>]
     A key has been created.  Values for <type> are:
       - B :: primary and subkey
       - P :: primary
       - S :: subkey
     The fingerprint is one of the primary key for type B and P and the
     one of the subkey for S.  Handle is an arbitrary non-whitespace
     string used to match key parameters from batch key creation run.
 
 *** KEY_NOT_CREATED [<handle>]
     The key from batch run has not been created due to errors.
 
 *** TRUST_
     These are several similar status codes:
 
     - TRUST_UNDEFINED <error_token>
     - TRUST_NEVER     <error_token>
     - TRUST_MARGINAL  [0  [<validation_model>]]
     - TRUST_FULLY     [0  [<validation_model>]]
     - TRUST_ULTIMATE  [0  [<validation_model>]]
 
     For good signatures one of these status lines are emitted to
     indicate the validity of the key used to create the signature.
     The error token values are currently only emitted by gpgsm.
 
     VALIDATION_MODEL describes the algorithm used to check the
     validity of the key.  The defaults are the standard Web of Trust
     model for gpg and the standard X.509 model for gpgsm.  The
     defined values are
 
        - pgp   :: The standard PGP WoT.
        - shell :: The standard X.509 model.
        - chain :: The chain model.
        - steed :: The STEED model.
        - tofu  :: The TOFU model
 
     Note that the term =TRUST_= in the status names is used for
     historic reasons; we now speak of validity.
 
 *** TOFU_USER <fingerprint_in_hex> <mbox>
 
     This status identifies the key and the userid for all following
     Tofu information.  The fingerprint is the fingerprint of the
     primary key and the mbox is in general the addr-spec part of the
     userid encoded in UTF-8 and percent escaped.  The fingerprint is
     identical for all TOFU_USER lines up to a NEWSIG line.
 
 *** TOFU_STATS <MANY_ARGS>
 
     Statistics for the current user id.
 
     The <MANY_ARGS> are the usual space delimited arguments.  Here we
     have too many of them to fit on one printed line and thus they are
     given on 3 printed lines:
 
     : <summary> <sign-count> <encryption-count>
     : [<policy> [<tm1> <tm2> <tm3> <tm4>
     : [<validity> [<sign-days> <encrypt-days>]]]]
 
     Values for SUMMARY are:
     - 0 :: attention, an interaction with the user is required (conflict)
     - 1 :: key with no verification/encryption history
     - 2 :: key with little history
     - 3 :: key with enough history for basic trust
     - 4 :: key with a lot of history
 
     Values for POLICY are:
     - none    :: No Policy set
     - auto    :: Policy is "auto"
     - good    :: Policy is "good"
     - bad     :: Policy is "bad"
     - ask     :: Policy is "ask"
     - unknown :: Policy is "unknown" (TOFU information does not
                  contribute to the key's validity)
 
     TM1 is the time the first message was verified.  TM2 is the time
     the most recent message was verified.  TM3 is the time the first
     message was encrypted.  TM4 is the most recent encryption. All may
     either be seconds since Epoch or an ISO time string
     (yyyymmddThhmmss).
 
     VALIDITY is the same as SUMMARY with the exception that VALIDITY
     doesn't reflect whether the key needs attention.  That is it never
     takes on value 0.  Instead, if there is a conflict, VALIDITY still
     reflects the key's validity (values: 1-4).
 
     SUMMARY values use the euclidean distance (m = sqrt(a² + b²)) rather
     then the sum of the magnitudes (m = a + b) to ensure a balance between
     verified signatures and encrypted messages.
 
     Values are calculated based on the number of days where a key was used
     for verifying a signature or to encrypt to it.
     The ranges for the values are:
 
     - 1 :: signature_days + encryption_days == 0
     - 2 :: 1 <= sqrt(signature_days² + encryption_days²) < 8
     - 3 :: 8 <= sqrt(signature_days² + encryption_days²) < 42
     - 4 :: sqrt(signature_days² + encryption_days²) >= 42
 
     SIGN-COUNT and ENCRYPTION-COUNT are the number of messages that we
     have seen that have been signed by this key / encryption to this
     key.
 
     SIGN-DAYS and ENCRYPTION-DAYS are similar, but the number of days
     (in UTC) on which we have seen messages signed by this key /
     encrypted to this key.
 
 *** TOFU_STATS_SHORT <long_string>
 
     Information about the TOFU binding for the signature.
     Example: "15 signatures verified. 10 messages encrypted"
 
 *** TOFU_STATS_LONG <long_string>
 
     Information about the TOFU binding for the signature in verbose
     format.  The LONG_STRING is percent escaped.
     Example: 'Verified 9 messages signed by "Werner Koch
     (dist sig)" in the past 3 minutes, 40 seconds.  The most
     recent message was verified 4 seconds ago.'
 
 *** PKA_TRUST_
     This is one of:
 
     - PKA_TRUST_GOOD <addr-spec>
     - PKA_TRUST_BAD  <addr-spec>
 
     Depending on the outcome of the PKA check one of the above status
     codes is emitted in addition to a =TRUST_*= status.
 
 ** Remote control
 *** GET_BOOL, GET_LINE, GET_HIDDEN, GOT_IT
 
     These status line are used with --command-fd for interactive
     control of the process.
 
 *** USERID_HINT <long main keyid> <string>
     Give a hint about the user ID for a certain keyID.
 
 *** NEED_PASSPHRASE <long keyid> <long main keyid> <keytype> <keylength>
     Issued whenever a passphrase is needed.  KEYTYPE is the numerical
     value of the public key algorithm or 0 if this is not applicable,
     KEYLENGTH is the length of the key or 0 if it is not known (this
     is currently always the case).
 
 *** NEED_PASSPHRASE_SYM <cipher_algo> <s2k_mode> <s2k_hash>
     Issued whenever a passphrase for symmetric encryption is needed.
 
 *** NEED_PASSPHRASE_PIN <card_type> <chvno> [<serialno>]
     Issued whenever a PIN is requested to unlock a card.
 
 *** MISSING_PASSPHRASE
     No passphrase was supplied.  An application which encounters this
     message may want to stop parsing immediately because the next
     message will probably be a BAD_PASSPHRASE.  However, if the
     application is a wrapper around the key edit menu functionality it
     might not make sense to stop parsing but simply ignoring the
     following BAD_PASSPHRASE.
 
 *** BAD_PASSPHRASE <long keyid>
     The supplied passphrase was wrong or not given.  In the latter
     case you may have seen a MISSING_PASSPHRASE.
 
 *** GOOD_PASSPHRASE
     The supplied passphrase was good and the secret key material
     is therefore usable.
 
 ** Import/Export
 *** IMPORT_CHECK <long keyid> <fingerprint> <user ID>
     This status is emitted in interactive mode right before
     the "import.okay" prompt.
 
 *** IMPORTED   <long keyid>  <username>
     The keyid and name of the signature just imported
 
 *** IMPORT_OK  <reason> [<fingerprint>]
     The key with the primary key's FINGERPRINT has been imported.
     REASON flags are:
 
     - 0 :: Not actually changed
     - 1 :: Entirely new key.
     - 2 :: New user IDs
     - 4 :: New signatures
     - 8 :: New subkeys
     - 16 :: Contains private key.
 
     The flags may be ORed.
 
 *** IMPORT_PROBLEM <reason> [<fingerprint>]
     Issued for each import failure.  Reason codes are:
 
     - 0 :: No specific reason given.
     - 1 :: Invalid Certificate.
     - 2 :: Issuer Certificate missing.
     - 3 :: Certificate Chain too long.
     - 4 :: Error storing certificate.
 
 *** IMPORT_RES <args>
     Final statistics on import process (this is one long line). The
     args are a list of unsigned numbers separated by white space:
 
     - <count>
     - <no_user_id>
     - <imported>
     - always 0 (formerly used for the number of RSA keys)
     - <unchanged>
     - <n_uids>
     - <n_subk>
     - <n_sigs>
     - <n_revoc>
     - <sec_read>
     - <sec_imported>
     - <sec_dups>
     - <skipped_new_keys>
     - <not_imported>
     - <skipped_v3_keys>
 
 *** EXPORTED  <fingerprint>
     The key with <fingerprint> has been exported.  The fingerprint is
     the fingerprint of the primary key even if the primary key has
     been replaced by a stub key during secret key export.
 
 *** EXPORT_RES <args>
 
     Final statistics on export process (this is one long line). The
     args are a list of unsigned numbers separated by white space:
 
     - <count>
     - <secret_count>
     - <exported>
 
 
 ** Smartcard related
 *** CARDCTRL <what> [<serialno>]
     This is used to control smartcard operations.  Defined values for
     WHAT are:
 
       - 1 :: Request insertion of a card.  Serialnumber may be given
              to request a specific card.  Used by gpg 1.4 w/o
              scdaemon
       - 2 :: Request removal of a card.  Used by gpg 1.4 w/o scdaemon.
       - 3 :: Card with serialnumber detected
       - 4 :: No card available
       - 5 :: No card reader available
       - 6 :: No card support available
       - 7 :: Card is in termination state
 
 *** SC_OP_FAILURE [<code>]
     An operation on a smartcard definitely failed.  Currently there is
     no indication of the actual error code, but application should be
     prepared to later accept more arguments.  Defined values for
     <code> are:
 
       - 0 :: unspecified error (identically to a missing CODE)
       - 1 :: canceled
       - 2 :: bad PIN
 
 *** SC_OP_SUCCESS
     A smart card operation succeeded.  This status is only printed for
     certain operation and is mostly useful to check whether a PIN
     change really worked.
 
 ** Miscellaneous status codes
 *** NODATA  <what>
     No data has been found.  Codes for WHAT are:
 
     - 1 :: No armored data.
     - 2 :: Expected a packet but did not found one.
     - 3 :: Invalid packet found, this may indicate a non OpenPGP
            message.
     - 4 :: Signature expected but not found
 
     You may see more than one of these status lines.
 
 *** UNEXPECTED <what>
     Unexpected data has been encountered.  Codes for WHAT are:
     - 0 :: Not further specified
     - 1 :: Corrupted message structure
 
 *** TRUNCATED <maxno>
     The output was truncated to MAXNO items.  This status code is
     issued for certain external requests.
 
 *** ERROR <error location> <error code> [<more>]
     This is a generic error status message, it might be followed by
     error location specific data. <error code> and <error_location>
     should not contain spaces.  The error code is a either a string
     commencing with a letter or such a string prefixed with a
     numerical error code and an underscore; e.g.: "151011327_EOF".
 *** WARNING <location> <error code> [<text>]
     This is a generic warning status message, it might be followed by
     error location specific data. <error code> and <location>
     should not contain spaces.  The error code is a either a string
     commencing with a letter or such a string prefixed with a
     numerical error code and an underscore; e.g.: "151011327_EOF".
 *** SUCCESS [<location>]
     Positive confirmation that an operation succeeded.  It is used
     similar to ISO-C's EXIT_SUCCESS.  <location> is optional but if
     given should not contain spaces.  Used only with a few commands.
 
 *** FAILURE <location> <error_code>
     This is the counterpart to SUCCESS and used to indicate a program
     failure.  It is used similar to ISO-C's EXIT_FAILURE but allows
     conveying more information, in particular a gpg-error error code.
     That numerical error code may optionally have a suffix made of an
     underscore and a string with an error symbol like "151011327_EOF".
     A dash may be used instead of <location>.
 
 *** BADARMOR
     The ASCII armor is corrupted.  No arguments yet.
 
 *** DELETE_PROBLEM <reason_code>
     Deleting a key failed.  Reason codes are:
     - 1 :: No such key
     - 2 :: Must delete secret key first
     - 3 :: Ambiguous specification
     - 4 :: Key is stored on a smartcard.
 
 *** PROGRESS <what> <char> <cur> <total> [<units>]
     Used by the primegen and public key functions to indicate
     progress.  <char> is the character displayed with no --status-fd
     enabled, with the linefeed replaced by an 'X'.  <cur> is the
     current amount done and <total> is amount to be done; a <total> of
     0 indicates that the total amount is not known. Both are
     non-negative integers.  The condition
       :       TOTAL && CUR == TOTAL
     may be used to detect the end of an operation.
 
     Well known values for <what> are:
 
            - pk_dsa   :: DSA key generation
            - pk_elg   :: Elgamal key generation
            - primegen :: Prime generation
            - need_entropy :: Waiting for new entropy in the RNG
            - tick :: Generic tick without any special meaning - useful
                      for letting clients know that the server is still
                      working.
            - starting_agent :: A gpg-agent was started because it is not
                                 running as a daemon.
            - learncard :: Send by the agent and gpgsm while learing
                           the data of a smartcard.
            - card_busy :: A smartcard is still working
 
     When <what> refers to a file path, it may be truncated.
 
     <units> is sometimes used to describe the units for <current> and
     <total>.  For example "B", "KiB", or "MiB".
 
 *** BACKUP_KEY_CREATED <fingerprint> <fname>
     A backup of a key identified by <fingerprint> has been writte to
     the file <fname>; <fname> is percent-escaped.
 
 *** MOUNTPOINT <name>
     <name> is a percent-plus escaped filename describing the
     mountpoint for the current operation (e.g. used by "g13 --mount").
     This may either be the specified mountpoint or one randomly
     chosen by g13.
 
 *** PINENTRY_LAUNCHED <pid>[:<extra>]
     This status line is emitted by gpg to notify a client that a
     Pinentry has been launched.  <pid> is the PID of the Pinentry.  It
     may be used to display a hint to the user but can't be used to
     synchronize with Pinentry.  Note that there is also an Assuan
     inquiry line with the same name used internally or, if enabled,
     send to the client instead of this status line.  Such an inquiry
     may be used to sync with Pinentry
 
 ** Obsolete status codes
 *** SIGEXPIRED
     Removed on 2011-02-04.  This is deprecated in favor of KEYEXPIRED.
 *** RSA_OR_IDEA
     Obsolete.  This status message used to be emitted for requests to
     use the IDEA or RSA algorithms.  It has been dropped from GnuPG
     2.1 after the respective patents expired.
 *** SHM_INFO, SHM_GET, SHM_GET_BOOL, SHM_GET_HIDDEN
     These were used for the ancient shared memory based co-processing.
 *** BEGIN_STREAM, END_STREAM
     Used to issued by the experimental pipemode.
 
 ** Inter-component codes
    Status codes are also used between the components of the GnuPG
    system via the Assuan S lines.  Some of them are documented here:
 
 *** PUBKEY_INFO <n> <ubid>
     The type of the public key in the following D-lines or
     communicated via a pipe.  <n> is the value of =enum pubkey_types=
-    and <ubid> the Unique Blob ID which is a SHA-1 digest the entire
-    blob here formatted in hex..  The consumer of this status line
-    should be prepared to see a <ubid> of up to 64 characters.
-
+    and <ubid> the Unique Blob ID (UBID) which is a SHA-1 digest the
+    entire blob here formatted in hex.  The consumer of this status
+    line should be prepared to see a <ubid> of up to 64 characters.
+    Note that the keyboxd SEARCH command can be used to lookup the
+    public key using the <ubid> prefixed with a caret (^).
 
 * Format of the --attribute-fd output
 
   When --attribute-fd is set, during key listings (--list-keys,
   --list-secret-keys) GnuPG dumps each attribute packet to the file
   descriptor specified.  --attribute-fd is intended for use with
   --status-fd as part of the required information is carried on the
   ATTRIBUTE status tag (see above).
 
   The contents of the attribute data is specified by RFC 4880.  For
   convenience, here is the Photo ID format, as it is currently the
   only attribute defined:
 
   - Byte 0-1 :: The length of the image header.  Due to a historical
                 accident (i.e. oops!) back in the NAI PGP days, this
                 is a little-endian number.  Currently 16 (0x10 0x00).
 
   - Byte 2 :: The image header version.  Currently 0x01.
 
   - Byte 3 :: Encoding format.  0x01 == JPEG.
 
   - Byte 4-15 :: Reserved, and currently unused.
 
   All other data after this header is raw image (JPEG) data.
 
 
 * Layout of the TrustDB
 
   The TrustDB is built from fixed length records, where the first byte
   describes the record type.  All numeric values are stored in network
   byte order.  The length of each record is 40 bytes.  The first
   record of the DB is always of type 1 and this is the only record of
   this type.
 
   The record types: directory(2), key(3), uid(4), pref(5), sigrec(6),
   and shadow directory(8) are not anymore used by version 2 of the
   TrustDB.
 
 ** Record type 0
 
    Unused record or deleted, can be reused for any purpose.  Such
    records should in general not exist because deleted records are of
    type 254 and kept in a linked list.
 
 ** Version info (RECTYPE_VER, 1)
 
    Version information for this TrustDB.  This is always the first
    record of the DB and the only one of this type.
 
    - 1 u8 :: Record type (value: 1).
    - 3 byte :: Magic value ("gpg")
    - 1 u8 :: TrustDB version (value: 2).
    - 1 u8 :: =marginals=. How many marginal trusted keys are required.
    - 1 u8 :: =completes=. How many completely trusted keys are
              required.
    - 1 u8 :: =max_cert_depth=.  How deep is the WoT evaluated.  Along
              with =marginals= and =completes=, this value is used to
              check whether the cached validity value from a [FIXME
              dir] record can be used.
    - 1 u8 :: =trust_model=
    - 1 u8 :: =min_cert_level=
    - 2 byte :: Not used
    - 1 u32 :: =created=. Timestamp of trustdb creation.
    - 1 u32 :: =nextcheck=. Timestamp of last modification which may
               affect the validity of keys in the trustdb.  This value
               is checked against the validity timestamp in the dir
               records.
    - 1 u32 :: =reserved=.  Not used.
    - 1 u32 :: =reserved2=. Not used.
    - 1 u32 :: =firstfree=. Number of the record with the head record
               of the RECTYPE_FREE linked list.
    - 1 u32 :: =reserved3=. Not used.
    - 1 u32 :: =trusthashtbl=. Record number of the trusthashtable.
 
 
 ** Hash table (RECTYPE_HTBL, 10)
 
    Due to the fact that we use fingerprints to lookup keys, we can
    implement quick access by some simple hash methods, and avoid the
    overhead of gdbm.  A property of fingerprints is that they can be
    used directly as hash values.  What we use is a dynamic multilevel
    architecture, which combines hash tables, record lists, and linked
    lists.
 
    This record is a hash table of 256 entries with the property that
    all these records are stored consecutively to make one big
    table. The hash value is simple the 1st, 2nd, ... byte of the
    fingerprint (depending on the indirection level).
 
    - 1 u8 :: Record type (value: 10).
    - 1 u8 :: Reserved
    - n u32 :: =recnum=.  A table with the hash table items fitting into
               this record.  =n= depends on the record length:
               $n=(reclen-2)/4$ which yields 9 for oure current record
               length of 40 bytes.
 
    The total number of hash table records to form the table is:
    $m=(256+n-1)/n$.  This is 29 for our record length of 40.
 
    To look up a key we use the first byte of the fingerprint to get
    the recnum from this hash table and then look up the addressed
    record:
 
    - If that record is another hash table, we use 2nd byte to index
      that hash table and so on;
    - if that record is a hash list, we walk all entries until we find
      a matching one; or
    - if that record is a key record, we compare the fingerprint to
      decide whether it is the requested key;
 
 
 ** Hash list (RECTYPE_HLST, 11)
 
    See hash table above on how it is used.  It may also be used for
    other purposes.
 
    - 1 u8 :: Record type (value: 11).
    - 1 u8 :: Reserved.
    - 1 u32 :: =next=.  Record number of the next hash list record or 0
               if none.
    - n u32 :: =rnum=.  Array with record numbers to values.  With
               $n=(reclen-5)/5$ and our record length of 40, n is 7.
 
 ** Trust record (RECTYPE_TRUST, 12)
 
    - 1 u8 :: Record type (value: 12).
    - 1 u8 :: Reserved.
    - 20 byte :: =fingerprint=.
    - 1 u8 :: =ownertrust=.
    - 1 u8 :: =depth=.
    - 1 u8 :: =min_ownertrust=.
    - 1 byte :: Not used.
    - 1 u32 :: =validlist=.
    - 10 byte :: Not used.
 
 ** Validity record (RECTYPE_VALID, 13)
 
    - 1 u8 :: Record type (value: 13).
    - 1 u8 :: Reserved.
    - 20 byte :: =namehash=.
    - 1 u8 :: =validity=
    - 1 u32 :: =next=.
    - 1 u8 :: =full_count=.
    - 1 u8 :: =marginal_count=.
    - 11 byte :: Not used.
 
 ** Free record (RECTYPE_FREE, 254)
 
    All these records form a linked list of unused records in the TrustDB.
 
    - 1 u8 :: Record type (value: 254)
    - 1 u8 :: Reserved.
    - 1 u32 :: =next=.  Record number of the next rcord of this type.
               The record number to the head of this linked list is
               stored in the version info record.
 
 
 * Database scheme for the TOFU info
 
 #+begin_src sql
 --
 -- The VERSION table holds the version of our TOFU data structures.
 --
 CREATE TABLE version (
   version integer -- As of now this is always 1
 );
 
 --
 -- The BINDINGS table associates mail addresses with keys.
 --
 CREATE TABLE bindings (
   oid integer primary key autoincrement,
   fingerprint text, -- The key's fingerprint in hex
   email text,       -- The normalized mail address destilled from user_id
   user_id text,     -- The unmodified user id
   time integer,     -- The time this binding was first observed.
   policy boolean check
        (policy in (1, 2, 3, 4, 5)), -- The trust policy with the values:
                                     --   1 := Auto
                                     --   2 := Good
                                     --   3 := Unknown
                                     --   4 := Bad
                                     --   5 := Ask
   conflict string,  -- NULL or a hex formatted fingerprint.
   unique (fingerprint, email)
 );
 
 CREATE INDEX bindings_fingerprint_email on bindings (fingerprint, email);
 CREATE INDEX bindings_email on bindings (email);
 
 --
 -- The SIGNATURES table records all data signatures we verified
 --
 CREATE TABLE signatures (
   binding integer not null, -- Link to bindings table,
                             -- references bindings.oid.
   sig_digest text,          -- The digest of the signed message.
   origin text,              -- String describing who initially fed
                             -- the signature to gpg (e.g. "email:claws").
   sig_time integer,         -- Timestamp from the signature.
   time integer,             -- Time this record was created.
   primary key (binding, sig_digest, origin)
 );
 #+end_src
 
 
 * GNU extensions to the S2K algorithm
 
   1 octet  - S2K Usage: either 254 or 255.
   1 octet  - S2K Cipher Algo: 0
   1 octet  - S2K Specifier: 101
   3 octets - "GNU"
   1 octet  - GNU S2K Extension Number.
 
   If such a GNU extension is used neither an IV nor any kind of
   checksum is used.  The defined GNU S2K Extension Numbers are:
 
   - 1 :: Do not store the secret part at all.  No specific data
          follows.
 
   - 2 :: A stub to access smartcards.  This data follows:
          - One octet with the length of the following serial number.
          - The serial number. Regardless of what the length octet
            indicates no more than 16 octets are stored.
 
   Note that gpg stores the GNU S2K Extension Number internally as an
   S2K Specifier with an offset of 1000.
 
 
 * Format of the OpenPGP TRUST packet
 
   According to RFC4880 (5.10), the trust packet (aka ring trust) is
   only used within keyrings and contains data that records the user's
   specifications of which key holds trusted introducers.  The RFC also
   states that the format of this packet is implementation defined and
   SHOULD NOT be emitted to output streams or should be ignored on
   import.  GnuPG uses this packet in several additional ways:
 
   - 1 octet :: Trust-Value (only used by Subtype SIG)
   - 1 octet :: Signature-Cache (only used by Subtype SIG; value must
                be less than 128)
   - 3 octets :: Fixed value: "gpg"
   - 1 octet  :: Subtype
                - 0 :: Signature cache (SIG)
                - 1 :: Key source on the primary key (KEY)
                - 2 :: Key source on a user id (UID)
   - 1 octet :: Key Source; i.e. the origin of the key:
                - 0 :: Unknown source.
                - 1 :: Public keyserver.
                - 2 :: Preferred keyserver.
                - 3 :: OpenPGP DANE.
                - 4 :: Web Key Directory.
                - 5 :: Import from a trusted URL.
                - 6 :: Import from a trusted file.
                - 7 :: Self generated.
   - 4 octets :: Time of last update.  This is a a four-octet scalar
                 with the seconds since Epoch.
   - 1 octet  :: Scalar with the length of the following field.
   - N octets :: String with the URL of the source.  This may be a
                 zero-length string.
 
   If the packets contains only two octets a Subtype of 0 is assumed;
   this is the only format recognized by GnuPG versions < 2.1.18.
   Trust-Value and Signature-Cache must be zero for all subtypes other
   than SIG.
 
 
 * Keyserver helper message format
 
   *This information is obsolete*
   (Keyserver helpers have been replaced by dirmngr)
 
   The keyserver may be contacted by a Unix Domain socket or via TCP.
 
   The format of a request is:
 #+begin_example
   command-tag
   "Content-length:" digits
   CRLF
 #+end_example
 
   Where command-tag is
 
 #+begin_example
   NOOP
   GET <user-name>
   PUT
   DELETE <user-name>
 #+end_example
 
 The format of a response is:
 
 #+begin_example
   "GNUPG/1.0" status-code status-text
   "Content-length:" digits
   CRLF
 #+end_example
 followed by <digits> bytes of data
 
 Status codes are:
 
   - 1xx :: Informational - Request received, continuing process
 
   - 2xx :: Success - The action was successfully received, understood,
            and accepted
 
   - 4xx :: Client Error - The request contains bad syntax or cannot be
            fulfilled
 
   - 5xx :: Server Error - The server failed to fulfill an apparently
            valid request
 
 
 * Object identifiers
 
   OIDs below the GnuPG arc:
 
 #+begin_example
   1.3.6.1.4.1.11591.2          GnuPG
   1.3.6.1.4.1.11591.2.1          notation
   1.3.6.1.4.1.11591.2.1.1          pkaAddress
   1.3.6.1.4.1.11591.2.2          X.509 extensions
   1.3.6.1.4.1.11591.2.2.1          standaloneCertificate
   1.3.6.1.4.1.11591.2.2.2          wellKnownPrivateKey
   1.3.6.1.4.1.11591.2.12242973   invalid encoded OID
 #+end_example
 
 
 
 * Debug flags
 
 This tables gives the flag values for the --debug option along with
 the alternative names used by the components.
 
 |       | gpg     | gpgsm   | agent   | scd     | dirmngr | g13     | wks     |
 |-------+---------+---------+---------+---------+---------+---------+---------|
 |     1 | packet  | x509    |         |         | x509    | mount   | mime    |
 |     2 | mpi     | mpi     | mpi     | mpi     |         |         | parser  |
 |     4 | crypto  | crypto  | crypto  | crypto  | crypto  | crypto  | crypto  |
 |     8 | filter  |         |         |         |         |         |         |
 |    16 | iobuf   |         |         |         | dns     |         |         |
 |    32 | memory  | memory  | memory  | memory  | memory  | memory  | memory  |
 |    64 | cache   | cache   | cache   | cache   | cache   |         |         |
 |   128 | memstat | memstat | memstat | memstat | memstat | memstat | memstat |
 |   256 | trust   |         |         |         |         |         |         |
 |   512 | hashing | hashing | hashing | hashing | hashing |         |         |
 |  1024 | ipc     | ipc     | ipc     | ipc     | ipc     | ipc     | ipc     |
 |  2048 |         |         |         | cardio  | network |         |         |
 |  4096 | clock   |         |         | reader  |         |         |         |
 |  8192 | lookup  |         |         |         | lookup  |         |         |
 | 16384 | extprog |         |         |         |         |         | extprog |
 
 Description of some debug flags:
 
   - cardio :: Used by scdaemon to trace the APDUs exchange with the
               card.
   - clock  :: Show execution times of certain functions.
   - crypto :: Trace crypto operations.
   - hashing :: Create files with the hashed data.
   - ipc :: Trace the Assuan commands.
   - mpi :: Show the values of the MPIs.
   - reader :: Used by scdaemon to trace card reader related code.  For
               example: Open and close reader.
 
 
 
 * Miscellaneous notes
 
 ** v3 fingerprints
    For packet version 3 we calculate the keyids this way:
     - RSA :: Low 64 bits of n
     - ELGAMAL :: Build a v3 pubkey packet (with CTB 0x99) and
                  calculate a RMD160 hash value from it. This is used
                  as the fingerprint and the low 64 bits are the keyid.
 
 ** Simplified revocation certificates
   Revocation certificates consist only of the signature packet;
   "--import" knows how to handle this.  The rationale behind it is to
   keep them small.
 
 ** Documentation on HKP (the http keyserver protocol):
 
    A minimalistic HTTP server on port 11371 recognizes a GET for
    /pks/lookup.  The standard http URL encoded query parameters are
    this (always key=value):
 
    - op=index (like pgp -kv), op=vindex (like pgp -kvv) and op=get (like
      pgp -kxa)
 
    - search=<stringlist>. This is a list of words that must occur in the key.
      The words are delimited with space, points, @ and so on. The delimiters
      are not searched for and the order of the words doesn't matter (but see
      next option).
 
    - exact=on. This switch tells the hkp server to only report exact matching
      keys back. In this case the order and the "delimiters" are important.
 
    - fingerprint=on. Also reports the fingerprints when used with 'index' or
      'vindex'
 
    The keyserver also recognizes http-POSTs to /pks/add. Use this to upload
    keys.
 
 
    A better way to do this would be a request like:
 
       /pks/lookup/<gnupg_formatierte_user_id>?op=<operation>
 
    This can be implemented using Hurd's translator mechanism.
    However, I think the whole keyserver stuff has to be re-thought;
    I have some ideas and probably create a white paper.
 ** Algorithm names for the "keygen.algo" prompt
 
   When using a --command-fd controlled key generation or "addkey"
   there is way to know the number to enter on the "keygen.algo"
   prompt.  The displayed numbers are for human reception and may
   change with releases.  To provide a stable way to enter a desired
   algorithm choice the prompt also accepts predefined names for the
   algorithms, which will not change.
 
    | Name    | No | Description                     |
    |---------+----+---------------------------------|
    | rsa+rsa |  1 | RSA and RSA (default)           |
    | dsa+elg |  2 | DSA and Elgamal                 |
    | dsa     |  3 | DSA (sign only)                 |
    | rsa/s   |  4 | RSA (sign only)                 |
    | elg     |  5 | Elgamal (encrypt only)          |
    | rsa/e   |  6 | RSA (encrypt only)              |
    | dsa/*   |  7 | DSA (set your own capabilities) |
    | rsa/*   |  8 | RSA (set your own capabilities) |
    | ecc+ecc |  9 | ECC and ECC                     |
    | ecc/s   | 10 | ECC (sign only)                 |
    | ecc/*   | 11 | ECC (set your own capabilities) |
    | ecc/e   | 12 | ECC (encrypt only)              |
    | keygrip | 13 | Existing key                    |
    | cardkey | 14 | Existing key from card          |
 
    If one of the "foo/*" names are used a "keygen.flags" prompt needs
    to be answered as well.  Instead of toggling the predefined flags,
    it is also possible to set them direct: Use a "=" character
    directly followed by a combination of "a" (for authentication), "s"
    (for signing), or "c" (for certification).
diff --git a/g10/call-keyboxd.c b/g10/call-keyboxd.c
index 97f84c03d..88ad07817 100644
--- a/g10/call-keyboxd.c
+++ b/g10/call-keyboxd.c
@@ -1,1104 +1,1112 @@
 /* call-keyboxd.c - Access to the keyboxd storage server
  * Copyright (C) 2019  g10 Code GmbH
  *
  * This file is part of GnuPG.
  *
  * GnuPG 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 3 of the License, or
  * (at your option) any later version.
  *
  * GnuPG 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 this program; if not, see <https://www.gnu.org/licenses/>.
  * SPDX-License-Identifier: GPL-3.0-or-later
  */
 
 #include <config.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <errno.h>
 #include <unistd.h>
 #include <time.h>
 #ifdef HAVE_LOCALE_H
 # include <locale.h>
 #endif
 #include <npth.h>
 
 #include "gpg.h"
 #include <assuan.h>
 #include "../common/util.h"
 #include "../common/membuf.h"
 #include "options.h"
 #include "../common/i18n.h"
 #include "../common/asshelp.h"
 #include "../common/host2net.h"
 #include "../common/exechelp.h"
 #include "../common/status.h"
 #include "keydb.h"
 
 #include "keydb-private.h"  /* For struct keydb_handle_s */
 
 
 /* Data used to keep track of keybox daemon sessions.  This allows us
  * to use several sessions with the keyboxd and also to re-use already
  * established sessions.  Note that gpg.h defines the type
  * keyboxd_local_t for this structure. */
 struct keyboxd_local_s
 {
   /* Link to other keyboxd contexts which are used simultaneously.  */
   struct keyboxd_local_s *next;
 
   /* The active Assuan context. */
   assuan_context_t ctx;
 
   /* This object is used if fd-passing is used to convey the
    * keyblocks.  */
   struct {
     /* NULL or a stream used to receive data.  */
     estream_t fp;
 
     /* Condition variable to sync the datastream with the command.  */
     npth_mutex_t mutex;
     npth_cond_t  cond;
 
     /* The found keyblock or the parsing error.   */
     kbnode_t found_keyblock;
     gpg_error_t found_err;
   } datastream;
 
   /* I/O buffer with the last search result or NULL.  Used if
    * D-lines are used to convey the keyblocks. */
   iobuf_t search_result;
 
   /* This flag set while an operation is running on this context.  */
   unsigned int is_active : 1;
 
   /* This flag is set to record that the standard per session init has
    * been done.  */
   unsigned int per_session_init_done : 1;
 
   /* Flag indicating that a search reset is required.  */
   unsigned int need_search_reset : 1;
 };
 
 
 /* Local prototypes.  */
 static void *datastream_thread (void *arg);
 
 
 
 
 static void
 lock_datastream (keyboxd_local_t kbl)
 {
   int rc = npth_mutex_lock (&kbl->datastream.mutex);
   if (rc)
     log_fatal ("%s: failed to acquire mutex: %s\n", __func__,
                gpg_strerror (gpg_error_from_errno (rc)));
 }
 
 
 static void
 unlock_datastream (keyboxd_local_t kbl)
 {
   int rc = npth_mutex_unlock (&kbl->datastream.mutex);
   if (rc)
     log_fatal ("%s: failed to release mutex: %s\n", __func__,
                gpg_strerror (gpg_error_from_errno (rc)));
 }
 
 
 /* Deinitialize all session resources pertaining to the keyboxd.  */
 void
 gpg_keyboxd_deinit_session_data (ctrl_t ctrl)
 {
   keyboxd_local_t kbl;
 
   while ((kbl = ctrl->keyboxd_local))
     {
       ctrl->keyboxd_local = kbl->next;
       if (kbl->is_active)
         log_error ("oops: trying to cleanup an active keyboxd context\n");
       else
         {
           es_fclose (kbl->datastream.fp);
           kbl->datastream.fp = NULL;
           assuan_release (kbl->ctx);
           kbl->ctx = NULL;
         }
       xfree (kbl);
     }
 }
 
 
 /* Print a warning if the server's version number is less than our
    version number.  Returns an error code on a connection problem.  */
 static gpg_error_t
 warn_version_mismatch (assuan_context_t ctx, const char *servername)
 {
   gpg_error_t err;
   char *serverversion;
   const char *myversion = strusage (13);
 
   err = get_assuan_server_version (ctx, 0, &serverversion);
   if (err)
     log_error (_("error getting version from '%s': %s\n"),
                servername, gpg_strerror (err));
   else if (compare_version_strings (serverversion, myversion) < 0)
     {
       char *warn;
 
       warn = xtryasprintf (_("server '%s' is older than us (%s < %s)"),
                            servername, serverversion, myversion);
       if (!warn)
         err = gpg_error_from_syserror ();
       else
         {
           log_info (_("WARNING: %s\n"), warn);
           if (!opt.quiet)
             {
               log_info (_("Note: Outdated servers may lack important"
                           " security fixes.\n"));
               log_info (_("Note: Use the command \"%s\" to restart them.\n"),
                         "gpgconf --kill all");
             }
 
           write_status_strings (STATUS_WARNING, "server_version_mismatch 0",
                                 " ", warn, NULL);
           xfree (warn);
         }
     }
   xfree (serverversion);
   return err;
 }
 
 
 /* Connect to the keybox daemon and launch it if necessary.  Handle
  * the server's initial greeting and set global options.  Returns a
  * new assuan context or an error.  */
 static gpg_error_t
 create_new_context (ctrl_t ctrl, assuan_context_t *r_ctx)
 {
   gpg_error_t err;
   assuan_context_t ctx;
 
   *r_ctx = NULL;
 
   err = start_new_keyboxd (&ctx,
                            GPG_ERR_SOURCE_DEFAULT,
                            opt.keyboxd_program,
                            opt.autostart, opt.verbose, DBG_IPC,
                            NULL, ctrl);
   if (!opt.autostart && gpg_err_code (err) == GPG_ERR_NO_KEYBOXD)
     {
       static int shown;
 
       if (!shown)
         {
           shown = 1;
           log_info (_("no keyboxd running in this session\n"));
         }
     }
   else if (!err && !(err = warn_version_mismatch (ctx, KEYBOXD_NAME)))
     {
       /* Place to emit global options.  */
     }
 
   if (err)
     assuan_release (ctx);
   else
     *r_ctx = ctx;
 
   return err;
 }
 
 
 
 /* Setup the pipe used for receiving data from the keyboxd.  Store the
  * info on KBL.  */
 static gpg_error_t
 prepare_data_pipe (keyboxd_local_t kbl)
 {
   gpg_error_t err;
   int rc;
   int inpipe[2];
   estream_t infp;
   npth_t thread;
   npth_attr_t tattr;
 
   err = gnupg_create_inbound_pipe (inpipe, &infp, 0);
   if (err)
     {
       log_error ("error creating inbound pipe: %s\n", gpg_strerror (err));
       return err;  /* That should not happen.  */
     }
 
   err = assuan_sendfd (kbl->ctx, INT2FD (inpipe[1]));
   if (err)
     {
       log_error ("sending sending fd %d to keyboxd: %s <%s>\n",
                  inpipe[1], gpg_strerror (err), gpg_strsource (err));
       es_fclose (infp);
       close (inpipe[1]);
       return 0; /* Server may not support fd-passing.  */
     }
 
   err = assuan_transact (kbl->ctx, "OUTPUT FD",
                          NULL, NULL, NULL, NULL, NULL, NULL);
   if (err)
     {
       log_info ("keyboxd does not accept our fd: %s <%s>\n",
                 gpg_strerror (err), gpg_strsource (err));
       es_fclose (infp);
       return 0;
     }
 
   kbl->datastream.fp = infp;
   kbl->datastream.found_keyblock = NULL;
   kbl->datastream.found_err = 0;
 
   rc = npth_attr_init (&tattr);
   if (rc)
     {
       err = gpg_error_from_errno (rc);
       log_error ("error preparing thread for keyboxd: %s\n",gpg_strerror (err));
       es_fclose (infp);
       kbl->datastream.fp = NULL;
       return err;
     }
   npth_attr_setdetachstate (&tattr, NPTH_CREATE_DETACHED);
   rc = npth_create (&thread, &tattr, datastream_thread, kbl);
   if (rc)
     {
       err = gpg_error_from_errno (rc);
       log_error ("error spawning thread for keyboxd: %s\n", gpg_strerror (err));
       npth_attr_destroy (&tattr);
       es_fclose (infp);
       kbl->datastream.fp = NULL;
       return err;
     }
 
   return 0;
 }
 
 
 /* Get a context for accessing keyboxd.  If no context is available a
  * new one is created and if necessary keyboxd is started.  R_KBL
  * receives a pointer to the local context object.  */
 static gpg_error_t
 open_context (ctrl_t ctrl, keyboxd_local_t *r_kbl)
 {
   gpg_error_t err;
   int rc;
   keyboxd_local_t kbl;
 
   *r_kbl = NULL;
   for (;;)
     {
       for (kbl = ctrl->keyboxd_local; kbl && kbl->is_active; kbl = kbl->next)
         ;
       if (kbl)
         {
           /* Found an inactive keyboxd session - return that.  */
           log_assert (!kbl->is_active);
 
           /* But first do the per session init if not yet done.  */
           if (!kbl->per_session_init_done)
             {
               err = prepare_data_pipe (kbl);
               if (err)
                 return err;
               kbl->per_session_init_done = 1;
             }
 
           kbl->is_active = 1;
           kbl->need_search_reset = 1;
 
           *r_kbl = kbl;
           return 0;
         }
 
       /* None found.  Create a new session and retry.  */
       kbl = xtrycalloc (1, sizeof *kbl);
       if (!kbl)
         return gpg_error_from_syserror ();
 
       rc = npth_mutex_init (&kbl->datastream.mutex, NULL);
       if (rc)
         {
           err = gpg_error_from_errno (rc);
           log_error ("error initializing mutex: %s\n", gpg_strerror (err));
           xfree (kbl);
           return err;
         }
       rc = npth_cond_init (&kbl->datastream.cond, NULL);
       if (rc)
         {
           err = gpg_error_from_errno (rc);
           log_error ("error initializing condition: %s\n", gpg_strerror (err));
           npth_mutex_destroy (&kbl->datastream.mutex);
           xfree (kbl);
           return err;
         }
 
       err = create_new_context (ctrl, &kbl->ctx);
       if (err)
         {
           npth_cond_destroy (&kbl->datastream.cond);
           npth_mutex_destroy (&kbl->datastream.mutex);
           xfree (kbl);
           return err;
         }
 
       /* For thread-saftey we add it to the list and retry; this is
        * easier than to employ a lock.  */
       kbl->next = ctrl->keyboxd_local;
       ctrl->keyboxd_local = kbl;
     }
   /*NOTREACHED*/
 }
 
 
 
 /* Create a new database handle.  A database handle is similar to a
  * file handle: it contains a local file position.  This is used when
  * searching: subsequent searches resume where the previous search
  * left off.  To rewind the position, use keydb_search_reset().  This
  * function returns NULL on error, sets ERRNO, and prints an error
  * diagnostic.  Depending on --use-keyboxd either the old internal
  * keydb code is used (keydb.c) or, if set, the processing is diverted
  * to the keyboxd. */
 /* FIXME: We should change the interface to return a gpg_error_t.  */
 KEYDB_HANDLE
 keydb_new (ctrl_t ctrl)
 {
   gpg_error_t err;
   KEYDB_HANDLE hd;
 
   if (DBG_CLOCK)
     log_clock ("keydb_new");
 
   hd = xtrycalloc (1, sizeof *hd);
   if (!hd)
     {
       err = gpg_error_from_syserror ();
       goto leave;
     }
 
   if (!opt.use_keyboxd)
     {
       err = internal_keydb_init (hd);
       goto leave;
     }
   hd->use_keyboxd = 1;
   hd->ctrl = ctrl;
 
   err = open_context (ctrl, &hd->kbl);
 
  leave:
   if (err)
     {
       int rc;
       log_error (_("error opening key DB: %s\n"), gpg_strerror (err));
       xfree (hd);
       hd = NULL;
       if (!(rc = gpg_err_code_to_errno (err)))
         rc = gpg_err_code_to_errno (GPG_ERR_EIO);
       gpg_err_set_errno (rc);
     }
   return hd;
 }
 
 
 /* Release a keydb handle.  */
 void
 keydb_release (KEYDB_HANDLE hd)
 {
   keyboxd_local_t kbl;
 
   if (!hd)
     return;
 
   if (DBG_CLOCK)
     log_clock ("keydb_release");
   if (!hd->use_keyboxd)
     internal_keydb_deinit (hd);
   else
     {
       kbl = hd->kbl;
       if (DBG_CLOCK)
         log_clock ("close_context (found)");
       if (!kbl->is_active)
         log_fatal ("closing inactive keyboxd context %p\n", kbl);
       kbl->is_active = 0;
       hd->kbl = NULL;
       hd->ctrl = NULL;
     }
   xfree (hd);
 }
 
 
 /* Take a lock if we are not using the keyboxd.  */
 gpg_error_t
 keydb_lock (KEYDB_HANDLE hd)
 {
   if (!hd)
     return gpg_error (GPG_ERR_INV_ARG);
 
   if (!hd->use_keyboxd)
     return internal_keydb_lock (hd);
 
   return 0;
 }
 
 
 
 /* FIXME: This helper is duplicates code of partse_keyblock_image.  */
 static gpg_error_t
 keydb_get_keyblock_do_parse (iobuf_t iobuf, int pk_no, int uid_no,
                              kbnode_t *r_keyblock)
 {
   gpg_error_t err;
   struct parse_packet_ctx_s parsectx;
   PACKET *pkt;
   kbnode_t keyblock = NULL;
   kbnode_t node, *tail;
   int in_cert, save_mode;
   int pk_count, uid_count;
 
   *r_keyblock = NULL;
 
   pkt = xtrymalloc (sizeof *pkt);
   if (!pkt)
     return gpg_error_from_syserror ();
   init_packet (pkt);
   init_parse_packet (&parsectx, iobuf);
   save_mode = set_packet_list_mode (0);
   in_cert = 0;
   tail = NULL;
   pk_count = uid_count = 0;
   while ((err = parse_packet (&parsectx, pkt)) != -1)
     {
       if (gpg_err_code (err) == GPG_ERR_UNKNOWN_PACKET)
         {
           free_packet (pkt, &parsectx);
           init_packet (pkt);
           continue;
 	}
       if (err)
         {
           es_fflush (es_stdout);
           log_error ("parse_keyblock_image: read error: %s\n",
                      gpg_strerror (err));
           if (gpg_err_code (err) == GPG_ERR_INV_PACKET)
             {
               free_packet (pkt, &parsectx);
               init_packet (pkt);
               continue;
             }
           err = gpg_error (GPG_ERR_INV_KEYRING);
           break;
         }
 
       /* Filter allowed packets.  */
       switch (pkt->pkttype)
         {
         case PKT_PUBLIC_KEY:
         case PKT_PUBLIC_SUBKEY:
         case PKT_SECRET_KEY:
         case PKT_SECRET_SUBKEY:
         case PKT_USER_ID:
         case PKT_ATTRIBUTE:
         case PKT_SIGNATURE:
         case PKT_RING_TRUST:
           break; /* Allowed per RFC.  */
 
         default:
           log_info ("skipped packet of type %d in keybox\n", (int)pkt->pkttype);
           free_packet(pkt, &parsectx);
           init_packet(pkt);
           continue;
         }
 
       /* Other sanity checks.  */
       if (!in_cert && pkt->pkttype != PKT_PUBLIC_KEY)
         {
           log_error ("parse_keyblock_image: first packet in a keybox blob "
                      "is not a public key packet\n");
           err = gpg_error (GPG_ERR_INV_KEYRING);
           break;
         }
       if (in_cert && (pkt->pkttype == PKT_PUBLIC_KEY
                       || pkt->pkttype == PKT_SECRET_KEY))
         {
           log_error ("parse_keyblock_image: "
                      "multiple keyblocks in a keybox blob\n");
           err = gpg_error (GPG_ERR_INV_KEYRING);
           break;
         }
       in_cert = 1;
 
       node = new_kbnode (pkt);
 
       switch (pkt->pkttype)
         {
         case PKT_PUBLIC_KEY:
         case PKT_PUBLIC_SUBKEY:
         case PKT_SECRET_KEY:
         case PKT_SECRET_SUBKEY:
           if (++pk_count == pk_no)
             node->flag |= 1;
           break;
 
         case PKT_USER_ID:
           if (++uid_count == uid_no)
             node->flag |= 2;
           break;
 
         default:
           break;
         }
 
       if (!keyblock)
         keyblock = node;
       else
         *tail = node;
       tail = &node->next;
       pkt = xtrymalloc (sizeof *pkt);
       if (!pkt)
         {
           err = gpg_error_from_syserror ();
           break;
         }
       init_packet (pkt);
     }
   set_packet_list_mode (save_mode);
 
   if (err == -1 && keyblock)
     err = 0; /* Got the entire keyblock.  */
 
   if (err)
     release_kbnode (keyblock);
   else
     {
       *r_keyblock = keyblock;
     }
   free_packet (pkt, &parsectx);
   deinit_parse_packet (&parsectx);
   xfree (pkt);
   return err;
 }
 
 
 /* The thread used to read from the data stream.  This is running as
  * long as the connection and its datastream exists.  */
 static void *
 datastream_thread (void *arg)
 {
   keyboxd_local_t kbl = arg;
   gpg_error_t err;
   int rc;
   unsigned char lenbuf[4];
   size_t nread, datalen;
   iobuf_t iobuf;
   int pk_no, uid_no;
   kbnode_t keyblock, tmpkeyblock;
 
 
   log_debug ("Datastream_thread started\n");
   while (kbl->datastream.fp)
     {
       /* log_debug ("Datastream_thread waiting ...\n"); */
       if (es_read (kbl->datastream.fp, lenbuf, 4, &nread))
         {
           err = gpg_error_from_syserror ();
           if (gpg_err_code (err) == GPG_ERR_EAGAIN)
             continue;
           log_error ("error reading data length from keyboxd: %s\n",
                      gpg_strerror (err));
           gnupg_sleep (1);
           continue;
         }
       if (nread != 4)
         {
           err = gpg_error (GPG_ERR_EIO);
           log_error ("error reading data length from keyboxd: %s\n",
                      "short read");
           continue;
         }
 
       datalen = buf32_to_size_t (lenbuf);
       /* log_debug ("keyboxd announced %zu bytes\n", datalen); */
 
       iobuf = iobuf_esopen (kbl->datastream.fp, "rb", 1, datalen);
       pk_no = uid_no = 0;  /* FIXME: Get this from the keyboxd.  */
       err = keydb_get_keyblock_do_parse (iobuf, pk_no, uid_no, &keyblock);
       iobuf_close (iobuf);
       if (!err)
         {
           /* log_debug ("parsing datastream succeeded\n"); */
 
           /* Thread-safe assignment to the result var:  */
           tmpkeyblock = kbl->datastream.found_keyblock;
           kbl->datastream.found_keyblock = keyblock;
           release_kbnode (tmpkeyblock);
       }
       else
         {
           /* log_debug ("parsing datastream failed: %s <%s>\n", */
           /*            gpg_strerror (err), gpg_strsource (err)); */
           tmpkeyblock = kbl->datastream.found_keyblock;
           kbl->datastream.found_keyblock = NULL;
           kbl->datastream.found_err = err;
           release_kbnode (tmpkeyblock);
         }
 
       /* Tell the main thread.  */
       lock_datastream (kbl);
       rc = npth_cond_signal (&kbl->datastream.cond);
       if (rc)
         {
           err = gpg_error_from_errno (rc);
           log_error ("%s: signaling condition failed: %s\n",
                      __func__, gpg_strerror (err));
         }
       unlock_datastream (kbl);
     }
   log_debug ("Datastream_thread finished\n");
 
   return NULL;
 }
 
 
 /* Return the keyblock last found by keydb_search() in *RET_KB.
  *
  * On success, the function returns 0 and the caller must free *RET_KB
  * using release_kbnode().  Otherwise, the function returns an error
  * code.
  *
  * The returned keyblock has the kbnode flag bit 0 set for the node
  * with the public key used to locate the keyblock or flag bit 1 set
  * for the user ID node.  */
 gpg_error_t
 keydb_get_keyblock (KEYDB_HANDLE hd, kbnode_t *ret_kb)
 {
   gpg_error_t err;
   int pk_no, uid_no;
 
   *ret_kb = NULL;
 
   if (!hd)
     return gpg_error (GPG_ERR_INV_ARG);
 
   if (DBG_CLOCK)
     log_clock ("%s enter", __func__);
 
   if (!hd->use_keyboxd)
     {
       err = internal_keydb_get_keyblock (hd, ret_kb);
       goto leave;
     }
 
   if (hd->kbl->search_result)
     {
       pk_no = uid_no = 0;  /*FIXME: Get this from the keyboxd.  */
       err = keydb_get_keyblock_do_parse (hd->kbl->search_result,
                                          pk_no, uid_no, ret_kb);
       /* In contrast to the old code we close the iobuf here and thus
        * this function may be called only once to get a keyblock.  */
       iobuf_close (hd->kbl->search_result);
       hd->kbl->search_result = NULL;
     }
   else if (hd->kbl->datastream.found_keyblock)
     {
       *ret_kb = hd->kbl->datastream.found_keyblock;
       hd->kbl->datastream.found_keyblock = NULL;
       err = 0;
     }
   else
     {
       err = gpg_error (GPG_ERR_VALUE_NOT_FOUND);
       goto leave;
     }
 
  leave:
   if (DBG_CLOCK)
     log_clock ("%s leave%s", __func__, err? " (failed)":"");
   return err;
 }
 
 
 /* Update the keyblock KB (i.e., extract the fingerprint and find the
  * corresponding keyblock in the keyring).
  *
  * This doesn't do anything if --dry-run was specified.
  *
  * Returns 0 on success.  Otherwise, it returns an error code.  Note:
  * if there isn't a keyblock in the keyring corresponding to KB, then
  * this function returns GPG_ERR_VALUE_NOT_FOUND.
  *
  * This function selects the matching record and modifies the current
  * file position to point to the record just after the selected entry.
  * Thus, if you do a subsequent search using HD, you should first do a
  * keydb_search_reset.  Further, if the selected record is important,
  * you should use keydb_push_found_state and keydb_pop_found_state to
  * save and restore it.  */
 gpg_error_t
 keydb_update_keyblock (ctrl_t ctrl, KEYDB_HANDLE hd, kbnode_t kb)
 {
   gpg_error_t err;
 
   log_assert (kb);
   log_assert (kb->pkt->pkttype == PKT_PUBLIC_KEY);
 
   if (!hd)
     return gpg_error (GPG_ERR_INV_ARG);
 
   if (!hd->use_keyboxd)
     {
       err = internal_keydb_update_keyblock (ctrl, hd, kb);
       goto leave;
     }
 
   err = GPG_ERR_NOT_IMPLEMENTED;
 
  leave:
   return err;
 }
 
 
 /* Insert a keyblock into one of the underlying keyrings or keyboxes.
  *
  * Be default, the keyring / keybox from which the last search result
  * came is used.  If there was no previous search result (or
  * keydb_search_reset was called), then the keyring / keybox where the
  * next search would start is used (i.e., the current file position).
  *
  * Note: this doesn't do anything if --dry-run was specified.
  *
  * Returns 0 on success.  Otherwise, it returns an error code.  */
 gpg_error_t
 keydb_insert_keyblock (KEYDB_HANDLE hd, kbnode_t kb)
 {
   gpg_error_t err;
 
   if (!hd)
     return gpg_error (GPG_ERR_INV_ARG);
 
   if (!hd->use_keyboxd)
     {
       err = internal_keydb_insert_keyblock (hd, kb);
       goto leave;
     }
 
   err = GPG_ERR_NOT_IMPLEMENTED;
 
  leave:
   return err;
 }
 
 
 /* Delete the currently selected keyblock.  If you haven't done a
  * search yet on this database handle (or called keydb_search_reset),
  * then this function returns an error.
  *
  * Returns 0 on success or an error code, if an error occured.  */
 gpg_error_t
 keydb_delete_keyblock (KEYDB_HANDLE hd)
 {
   gpg_error_t err;
 
   if (!hd)
     return gpg_error (GPG_ERR_INV_ARG);
 
   if (!hd->use_keyboxd)
     {
       err = internal_keydb_delete_keyblock (hd);
       goto leave;
     }
 
   err = GPG_ERR_NOT_IMPLEMENTED;
 
  leave:
   return err;
 }
 
 
 /* Clears the current search result and resets the handle's position
  * so that the next search starts at the beginning of the database.
  *
  * Returns 0 on success and an error code if an error occurred.  */
 gpg_error_t
 keydb_search_reset (KEYDB_HANDLE hd)
 {
   gpg_error_t err;
 
   if (!hd)
     return gpg_error (GPG_ERR_INV_ARG);
 
   if (DBG_CLOCK)
     log_clock ("%s", __func__);
   if (DBG_CACHE)
     log_debug ("%s (hd=%p)", __func__, hd);
 
   if (!hd->use_keyboxd)
     {
       err = internal_keydb_search_reset (hd);
       goto leave;
     }
 
   /* All we need todo is to tell search that a reset is pending.  Noet
    * that keydb_new sets this flag as well.  */
   hd->kbl->need_search_reset = 1;
   err = 0;
 
  leave:
   return err;
 }
 
 
 /* Search the database for keys matching the search description.  If
  * the DB contains any legacy keys, these are silently ignored.
  *
  * DESC is an array of search terms with NDESC entries.  The search
  * terms are or'd together.  That is, the next entry in the DB that
  * matches any of the descriptions will be returned.
  *
  * Note: this function resumes searching where the last search left
  * off (i.e., at the current file position).  If you want to search
  * from the start of the database, then you need to first call
  * keydb_search_reset().
  *
  * If no key matches the search description, returns
  * GPG_ERR_NOT_FOUND.  If there was a match, returns 0.  If an error
  * occurred, returns an error code.
  *
  * The returned key is considered to be selected and the raw data can,
  * for instance, be returned by calling keydb_get_keyblock().  */
 gpg_error_t
 keydb_search (KEYDB_HANDLE hd, KEYDB_SEARCH_DESC *desc,
               size_t ndesc, size_t *descindex)
 {
   gpg_error_t err;
   int i;
   char line[ASSUAN_LINELENGTH];
 
 
   if (!hd)
     return gpg_error (GPG_ERR_INV_ARG);
 
   if (descindex)
     *descindex = 0; /* Make sure it is always set on return.  */
 
   if (DBG_CLOCK)
     log_clock ("%s enter", __func__);
 
   if (DBG_LOOKUP)
     {
       log_debug ("%s: %zd search descriptions:\n", __func__, ndesc);
       for (i = 0; i < ndesc; i ++)
         {
           char *t = keydb_search_desc_dump (&desc[i]);
           log_debug ("%s   %d: %s\n", __func__, i, t);
           xfree (t);
         }
     }
 
   if (!hd->use_keyboxd)
     {
       err = internal_keydb_search (hd, desc, ndesc, descindex);
       goto leave;
     }
 
   /* Clear the result objects.  */
   if (hd->kbl->search_result)
     {
       iobuf_close (hd->kbl->search_result);
       hd->kbl->search_result = NULL;
     }
   if (hd->kbl->datastream.found_keyblock)
     {
       release_kbnode (hd->kbl->datastream.found_keyblock);
       hd->kbl->datastream.found_keyblock = NULL;
     }
 
   /* Check whether this is a NEXT search.  */
   if (!hd->kbl->need_search_reset)
     {
       /* No reset requested thus continue the search.  The keyboxd
        * keeps the context of the search and thus the NEXT operates on
        * the last search pattern.  This is how we always used the
        * keydb.c functions.  In theory we were able to modify the
        * search pattern between searches but that is not anymore
        * supported by keyboxd and a cursory check does not show that
        * we actually made used of that misfeature.  */
       snprintf (line, sizeof line, "NEXT");
       goto do_search;
     }
 
   hd->kbl->need_search_reset = 0;
 
   if (!ndesc)
     {
       err = gpg_error (GPG_ERR_INV_ARG);
       goto leave;
     }
 
   /* FIXME: Implement --multi */
   switch (desc->mode)
     {
     case KEYDB_SEARCH_MODE_EXACT:
       snprintf (line, sizeof line, "SEARCH =%s", desc[0].u.name);
       break;
 
     case KEYDB_SEARCH_MODE_SUBSTR:
       snprintf (line, sizeof line, "SEARCH *%s", desc[0].u.name);
       break;
 
     case KEYDB_SEARCH_MODE_MAIL:
       snprintf (line, sizeof line, "SEARCH <%s", desc[0].u.name);
       break;
 
     case KEYDB_SEARCH_MODE_MAILSUB:
       snprintf (line, sizeof line, "SEARCH @%s", desc[0].u.name);
       break;
 
     case KEYDB_SEARCH_MODE_MAILEND:
       snprintf (line, sizeof line, "SEARCH .%s", desc[0].u.name);
       break;
 
     case KEYDB_SEARCH_MODE_WORDS:
       snprintf (line, sizeof line, "SEARCH +%s", desc[0].u.name);
       break;
 
     case KEYDB_SEARCH_MODE_SHORT_KID:
       snprintf (line, sizeof line, "SEARCH 0x%08lX",
                 (ulong)desc->u.kid[1]);
       break;
 
     case KEYDB_SEARCH_MODE_LONG_KID:
       snprintf (line, sizeof line, "SEARCH 0x%08lX%08lX",
                 (ulong)desc->u.kid[0], (ulong)desc->u.kid[1]);
       break;
 
     case KEYDB_SEARCH_MODE_FPR:
       {
         unsigned char hexfpr[MAX_FINGERPRINT_LEN * 2 + 1];
         log_assert (desc[0].fprlen <= MAX_FINGERPRINT_LEN);
         bin2hex (desc[0].u.fpr, desc[0].fprlen, hexfpr);
         snprintf (line, sizeof line, "SEARCH 0x%s", hexfpr);
       }
       break;
 
     case KEYDB_SEARCH_MODE_ISSUER:
       snprintf (line, sizeof line, "SEARCH #/%s", desc[0].u.name);
       break;
 
     case KEYDB_SEARCH_MODE_ISSUER_SN:
     case KEYDB_SEARCH_MODE_SN:
       snprintf (line, sizeof line, "SEARCH #%s", desc[0].u.name);
       break;
 
     case KEYDB_SEARCH_MODE_SUBJECT:
       snprintf (line, sizeof line, "SEARCH /%s", desc[0].u.name);
       break;
 
     case KEYDB_SEARCH_MODE_KEYGRIP:
       {
         unsigned char hexgrip[KEYGRIP_LEN * 2 + 1];
         bin2hex (desc[0].u.grip, KEYGRIP_LEN, hexgrip);
         snprintf (line, sizeof line, "SEARCH &%s", hexgrip);
       }
       break;
 
+    case KEYDB_SEARCH_MODE_UBID:
+      {
+        unsigned char hexubid[20 * 2 + 1];
+        bin2hex (desc[0].u.grip, 20, hexubid);
+        snprintf (line, sizeof line, "SEARCH ^%s", hexubid);
+      }
+      break;
+
     case KEYDB_SEARCH_MODE_FIRST:
       snprintf (line, sizeof line, "SEARCH");
       break;
 
     case KEYDB_SEARCH_MODE_NEXT:
       log_debug ("%s: mode next - we should not get to here!\n", __func__);
       snprintf (line, sizeof line, "NEXT");
       break;
 
     default:
       err = gpg_error (GPG_ERR_INV_ARG);
       goto leave;
     }
 
  do_search:
   if (hd->kbl->datastream.fp)
     {
       /* log_debug ("Sending command '%s'\n", line); */
       err = assuan_transact (hd->kbl->ctx, line,
                              NULL, NULL,
                              NULL, NULL,
                              NULL, NULL);
       if (err)
         {
           /* log_debug ("Finished command with error: %s\n", gpg_strerror (err)); */
           /* Fixme: On unexpected errors we need a way to cancek the
            * data stream.  Probly it will be best to closeand reopen
            * it.  */
         }
       else
         {
           int rc;
 
           /* log_debug ("Finished command .. telling data stream\n"); */
           lock_datastream (hd->kbl);
           if (!hd->kbl->datastream.found_keyblock)
             {
               /* log_debug ("%s: waiting on datastream_cond ...\n", __func__); */
               rc = npth_cond_wait (&hd->kbl->datastream.cond,
                                    &hd->kbl->datastream.mutex);
               /* log_debug ("%s: waiting on datastream.cond done\n", __func__); */
               if (rc)
                 {
                   err = gpg_error_from_errno (rc);
                   log_error ("%s: waiting on condition failed: %s\n",
                              __func__, gpg_strerror (err));
                 }
             }
           unlock_datastream (hd->kbl);
         }
     }
   else /* Slower D-line version if fd-passing was not successful.  */
     {
       membuf_t data;
       void *buffer;
       size_t len;
 
       init_membuf (&data, 8192);
       err = assuan_transact (hd->kbl->ctx, line,
                              put_membuf_cb, &data,
                              NULL, NULL,
                              NULL, NULL);
       if (err)
         {
           xfree (get_membuf (&data, &len));
           goto leave;
         }
 
       buffer = get_membuf (&data, &len);
       if (!buffer)
         {
           err = gpg_error_from_syserror ();
           goto leave;
         }
 
       hd->kbl->search_result = iobuf_temp_with_content (buffer, len);
       xfree (buffer);
   }
 
 
  leave:
   if (DBG_CLOCK)
     log_clock ("%s leave (%sfound)", __func__, err? "not ":"");
   return err;
 }
diff --git a/g10/keydb.c b/g10/keydb.c
index 6ca239475..39ec5442e 100644
--- a/g10/keydb.c
+++ b/g10/keydb.c
@@ -1,1973 +1,1981 @@
 /* keydb.c - key database dispatcher
  * Copyright (C) 2001-2013 Free Software Foundation, Inc.
  * Copyright (C) 2001-2015 Werner Koch
  *
  * This file is part of GnuPG.
  *
  * GnuPG 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 3 of the License, or
  * (at your option) any later version.
  *
  * GnuPG 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 this program; if not, see <https://www.gnu.org/licenses/>.
  */
 
 #include <config.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <errno.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <unistd.h>
 
 #include "gpg.h"
 #include "../common/util.h"
 #include "options.h"
 #include "main.h" /*try_make_homedir ()*/
 #include "packet.h"
 #include "keyring.h"
 #include "../kbx/keybox.h"
 #include "keydb.h"
 #include "../common/i18n.h"
 
 #include "keydb-private.h"  /* For struct keydb_handle_s */
 
 static int active_handles;
 
 
 static struct resource_item all_resources[MAX_KEYDB_RESOURCES];
 static int used_resources;
 
 /* A pointer used to check for the primary key database by comparing
    to the struct resource_item's TOKEN.  */
 static void *primary_keydb;
 
 /* Whether we have successfully registered any resource.  */
 static int any_registered;
 
 /* Looking up keys is expensive.  To hide the cost, we cache whether
    keys exist in the key database.  Then, if we know a key does not
    exist, we don't have to spend time looking it up.  This
    particularly helps the --list-sigs and --check-sigs commands.
 
    The cache stores the results in a hash using separate chaining.
    Concretely: we use the LSB of the keyid to index the hash table and
    each bucket consists of a linked list of entries.  An entry
    consists of the 64-bit key id.  If a key id is not in the cache,
    then we don't know whether it is in the DB or not.
 
    To simplify the cache consistency protocol, we simply flush the
    whole cache whenever a key is inserted or updated.  */
 
 #define KID_NOT_FOUND_CACHE_BUCKETS 256
 static struct kid_not_found_cache_bucket *
   kid_not_found_cache[KID_NOT_FOUND_CACHE_BUCKETS];
 
 struct kid_not_found_cache_bucket
 {
   struct kid_not_found_cache_bucket *next;
   u32 kid[2];
 };
 
 struct
 {
   unsigned int count;   /* The current number of entries in the hash table.  */
   unsigned int peak;    /* The peak of COUNT.  */
   unsigned int flushes; /* The number of flushes.  */
 } kid_not_found_stats;
 
 struct
 {
   unsigned int handles; /* Number of handles created.  */
   unsigned int locks;   /* Number of locks taken.  */
   unsigned int parse_keyblocks; /* Number of parse_keyblock_image calls.  */
   unsigned int get_keyblocks;   /* Number of keydb_get_keyblock calls.    */
   unsigned int build_keyblocks; /* Number of build_keyblock_image calls.  */
   unsigned int update_keyblocks;/* Number of update_keyblock calls.       */
   unsigned int insert_keyblocks;/* Number of update_keyblock calls.       */
   unsigned int delete_keyblocks;/* Number of delete_keyblock calls.       */
   unsigned int search_resets;   /* Number of keydb_search_reset calls.    */
   unsigned int found;           /* Number of successful keydb_search calls. */
   unsigned int found_cached;    /* Ditto but from the cache.              */
   unsigned int notfound;        /* Number of failed keydb_search calls.   */
   unsigned int notfound_cached; /* Ditto but from the cache.              */
 } keydb_stats;
 
 
 static int lock_all (KEYDB_HANDLE hd);
 static void unlock_all (KEYDB_HANDLE hd);
 
 
 /* Check whether the keyid KID is in key id is definitely not in the
    database.
 
    Returns:
 
      0 - Indeterminate: the key id is not in the cache; we don't know
          whether the key is in the database or not.  If you want a
          definitive answer, you'll need to perform a lookup.
 
      1 - There is definitely no key with this key id in the database.
          We searched for a key with this key id previously, but we
          didn't find it in the database.  */
 static int
 kid_not_found_p (u32 *kid)
 {
   struct kid_not_found_cache_bucket *k;
 
   for (k = kid_not_found_cache[kid[0] % KID_NOT_FOUND_CACHE_BUCKETS]; k; k = k->next)
     if (k->kid[0] == kid[0] && k->kid[1] == kid[1])
       {
         if (DBG_CACHE)
           log_debug ("keydb: kid_not_found_p (%08lx%08lx) => not in DB\n",
                      (ulong)kid[0], (ulong)kid[1]);
         return 1;
       }
 
   if (DBG_CACHE)
     log_debug ("keydb: kid_not_found_p (%08lx%08lx) => indeterminate\n",
                (ulong)kid[0], (ulong)kid[1]);
   return 0;
 }
 
 
 /* Insert the keyid KID into the kid_not_found_cache.  FOUND is whether
    the key is in the key database or not.
 
    Note this function does not check whether the key id is already in
    the cache.  As such, kid_not_found_p() should be called first.  */
 static void
 kid_not_found_insert (u32 *kid)
 {
   struct kid_not_found_cache_bucket *k;
 
   if (DBG_CACHE)
     log_debug ("keydb: kid_not_found_insert (%08lx%08lx)\n",
                (ulong)kid[0], (ulong)kid[1]);
   k = xmalloc (sizeof *k);
   k->kid[0] = kid[0];
   k->kid[1] = kid[1];
   k->next = kid_not_found_cache[kid[0] % KID_NOT_FOUND_CACHE_BUCKETS];
   kid_not_found_cache[kid[0] % KID_NOT_FOUND_CACHE_BUCKETS] = k;
   kid_not_found_stats.count++;
 }
 
 
 /* Flush the kid not found cache.  */
 static void
 kid_not_found_flush (void)
 {
   struct kid_not_found_cache_bucket *k, *knext;
   int i;
 
   if (DBG_CACHE)
     log_debug ("keydb: kid_not_found_flush\n");
 
   if (!kid_not_found_stats.count)
     return;
 
   for (i=0; i < DIM(kid_not_found_cache); i++)
     {
       for (k = kid_not_found_cache[i]; k; k = knext)
         {
           knext = k->next;
           xfree (k);
         }
       kid_not_found_cache[i] = NULL;
     }
   if (kid_not_found_stats.count > kid_not_found_stats.peak)
     kid_not_found_stats.peak = kid_not_found_stats.count;
   kid_not_found_stats.count = 0;
   kid_not_found_stats.flushes++;
 }
 
 
 static void
 keyblock_cache_clear (struct keydb_handle_s *hd)
 {
   hd->keyblock_cache.state = KEYBLOCK_CACHE_EMPTY;
   iobuf_close (hd->keyblock_cache.iobuf);
   hd->keyblock_cache.iobuf = NULL;
   hd->keyblock_cache.resource = -1;
   hd->keyblock_cache.offset = -1;
 }
 
 
 /* Handle the creation of a keyring or a keybox if it does not yet
    exist.  Take into account that other processes might have the
    keyring/keybox already locked.  This lock check does not work if
    the directory itself is not yet available.  If IS_BOX is true the
    filename is expected to refer to a keybox.  If FORCE_CREATE is true
    the keyring or keybox will be created.
 
    Return 0 if it is okay to access the specified file.  */
 static gpg_error_t
 maybe_create_keyring_or_box (char *filename, int is_box, int force_create)
 {
   dotlock_t lockhd = NULL;
   IOBUF iobuf;
   int rc;
   mode_t oldmask;
   char *last_slash_in_filename;
   char *bak_fname = NULL;
   char *tmp_fname = NULL;
   int save_slash;
 
   /* A quick test whether the filename already exists. */
   if (!access (filename, F_OK))
     return !access (filename, R_OK)? 0 : gpg_error (GPG_ERR_EACCES);
 
   /* If we don't want to create a new file at all, there is no need to
      go any further - bail out right here.  */
   if (!force_create)
     return gpg_error (GPG_ERR_ENOENT);
 
   /* First of all we try to create the home directory.  Note, that we
      don't do any locking here because any sane application of gpg
      would create the home directory by itself and not rely on gpg's
      tricky auto-creation which is anyway only done for certain home
      directory name pattern. */
   last_slash_in_filename = strrchr (filename, DIRSEP_C);
 #if HAVE_W32_SYSTEM
   {
     /* Windows may either have a slash or a backslash.  Take care of it.  */
     char *p = strrchr (filename, '/');
     if (!last_slash_in_filename || p > last_slash_in_filename)
       last_slash_in_filename = p;
   }
 #endif /*HAVE_W32_SYSTEM*/
   if (!last_slash_in_filename)
     return gpg_error (GPG_ERR_ENOENT);  /* No slash at all - should
                                            not happen though.  */
   save_slash = *last_slash_in_filename;
   *last_slash_in_filename = 0;
   if (access(filename, F_OK))
     {
       static int tried;
 
       if (!tried)
         {
           tried = 1;
           try_make_homedir (filename);
         }
       if (access (filename, F_OK))
         {
           rc = gpg_error_from_syserror ();
           *last_slash_in_filename = save_slash;
           goto leave;
         }
     }
   *last_slash_in_filename = save_slash;
 
   /* To avoid races with other instances of gpg trying to create or
      update the keyring (it is removed during an update for a short
      time), we do the next stuff in a locked state. */
   lockhd = dotlock_create (filename, 0);
   if (!lockhd)
     {
       rc = gpg_error_from_syserror ();
       /* A reason for this to fail is that the directory is not
          writable. However, this whole locking stuff does not make
          sense if this is the case. An empty non-writable directory
          with no keyring is not really useful at all. */
       if (opt.verbose)
         log_info ("can't allocate lock for '%s': %s\n",
                   filename, gpg_strerror (rc));
 
       if (!force_create)
         return gpg_error (GPG_ERR_ENOENT);  /* Won't happen.  */
       else
         return rc;
     }
 
   if ( dotlock_take (lockhd, -1) )
     {
       rc = gpg_error_from_syserror ();
       /* This is something bad.  Probably a stale lockfile.  */
       log_info ("can't lock '%s': %s\n", filename, gpg_strerror (rc));
       goto leave;
     }
 
   /* Now the real test while we are locked. */
 
   /* Gpg either uses pubring.gpg or pubring.kbx and thus different
    * lock files.  Now, when one gpg process is updating a pubring.gpg
    * and thus holding the corresponding lock, a second gpg process may
    * get to here at the time between the two rename operation used by
    * the first process to update pubring.gpg.  The lock taken above
    * may not protect the second process if it tries to create a
    * pubring.kbx file which would be protected by a different lock
    * file.
    *
    * We can detect this case by checking that the two temporary files
    * used by the update code exist at the same time.  In that case we
    * do not create a new file but act as if FORCE_CREATE has not been
    * given.  Obviously there is a race between our two checks but the
    * worst thing is that we won't create a new file, which is better
    * than to accidentally creating one.  */
   rc = keybox_tmp_names (filename, is_box, &bak_fname, &tmp_fname);
   if (rc)
     goto leave;
 
   if (!access (filename, F_OK))
     {
       rc = 0;  /* Okay, we may access the file now.  */
       goto leave;
     }
   if (!access (bak_fname, F_OK) && !access (tmp_fname, F_OK))
     {
       /* Very likely another process is updating a pubring.gpg and we
          should not create a pubring.kbx.  */
       rc = gpg_error (GPG_ERR_ENOENT);
       goto leave;
     }
 
 
   /* The file does not yet exist, create it now. */
   oldmask = umask (077);
   if (is_secured_filename (filename))
     {
       iobuf = NULL;
       gpg_err_set_errno (EPERM);
     }
   else
     iobuf = iobuf_create (filename, 0);
   umask (oldmask);
   if (!iobuf)
     {
       rc = gpg_error_from_syserror ();
       if (is_box)
         log_error (_("error creating keybox '%s': %s\n"),
                    filename, gpg_strerror (rc));
       else
         log_error (_("error creating keyring '%s': %s\n"),
                    filename, gpg_strerror (rc));
       goto leave;
     }
 
   iobuf_close (iobuf);
   /* Must invalidate that ugly cache */
   iobuf_ioctl (NULL, IOBUF_IOCTL_INVALIDATE_CACHE, 0, filename);
 
   /* Make sure that at least one record is in a new keybox file, so
      that the detection magic will work the next time it is used.  */
   if (is_box)
     {
       FILE *fp = fopen (filename, "wb");
       if (!fp)
         rc = gpg_error_from_syserror ();
       else
         {
           rc = _keybox_write_header_blob (fp, NULL, 1);
           fclose (fp);
         }
       if (rc)
         {
           if (is_box)
             log_error (_("error creating keybox '%s': %s\n"),
                        filename, gpg_strerror (rc));
           else
             log_error (_("error creating keyring '%s': %s\n"),
                        filename, gpg_strerror (rc));
           goto leave;
         }
     }
 
   if (!opt.quiet)
     {
       if (is_box)
         log_info (_("keybox '%s' created\n"), filename);
       else
         log_info (_("keyring '%s' created\n"), filename);
     }
 
   rc = 0;
 
  leave:
   if (lockhd)
     {
       dotlock_release (lockhd);
       dotlock_destroy (lockhd);
     }
   xfree (bak_fname);
   xfree (tmp_fname);
   return rc;
 }
 
 
 /* Helper for keydb_add_resource.  Opens FILENAME to figure out the
    resource type.
 
    Returns the specified file's likely type.  If the file does not
    exist, returns KEYDB_RESOURCE_TYPE_NONE and sets *R_FOUND to 0.
    Otherwise, tries to figure out the file's type.  This is either
    KEYDB_RESOURCE_TYPE_KEYBOX, KEYDB_RESOURCE_TYPE_KEYRING or
    KEYDB_RESOURCE_TYPE_KEYNONE.  If the file is a keybox and it has
    the OpenPGP flag set, then R_OPENPGP is also set.  */
 static KeydbResourceType
 rt_from_file (const char *filename, int *r_found, int *r_openpgp)
 {
   u32 magic;
   unsigned char verbuf[4];
   FILE *fp;
   KeydbResourceType rt = KEYDB_RESOURCE_TYPE_NONE;
 
   *r_found = *r_openpgp = 0;
   fp = fopen (filename, "rb");
   if (fp)
     {
       *r_found = 1;
 
       if (fread (&magic, 4, 1, fp) == 1 )
         {
           if (magic == 0x13579ace || magic == 0xce9a5713)
             ; /* GDBM magic - not anymore supported. */
           else if (fread (&verbuf, 4, 1, fp) == 1
                    && verbuf[0] == 1
                    && fread (&magic, 4, 1, fp) == 1
                    && !memcmp (&magic, "KBXf", 4))
             {
               if ((verbuf[3] & 0x02))
                 *r_openpgp = 1;
               rt = KEYDB_RESOURCE_TYPE_KEYBOX;
             }
           else
             rt = KEYDB_RESOURCE_TYPE_KEYRING;
         }
       else /* Maybe empty: assume keyring. */
         rt = KEYDB_RESOURCE_TYPE_KEYRING;
 
       fclose (fp);
     }
 
   return rt;
 }
 
 char *
 keydb_search_desc_dump (struct keydb_search_desc *desc)
 {
   char b[MAX_FORMATTED_FINGERPRINT_LEN + 1];
   char fpr[2 * MAX_FINGERPRINT_LEN + 1];
 
+#if MAX_FINGERPRINT_LEN < 20
+#error MAX_FINGERPRINT_LEN shorter than GRIP and UBID length/
+#endif
+
   switch (desc->mode)
     {
     case KEYDB_SEARCH_MODE_EXACT:
       return xasprintf ("EXACT: '%s'", desc->u.name);
     case KEYDB_SEARCH_MODE_SUBSTR:
       return xasprintf ("SUBSTR: '%s'", desc->u.name);
     case KEYDB_SEARCH_MODE_MAIL:
       return xasprintf ("MAIL: '%s'", desc->u.name);
     case KEYDB_SEARCH_MODE_MAILSUB:
       return xasprintf ("MAILSUB: '%s'", desc->u.name);
     case KEYDB_SEARCH_MODE_MAILEND:
       return xasprintf ("MAILEND: '%s'", desc->u.name);
     case KEYDB_SEARCH_MODE_WORDS:
       return xasprintf ("WORDS: '%s'", desc->u.name);
     case KEYDB_SEARCH_MODE_SHORT_KID:
       return xasprintf ("SHORT_KID: '%s'",
                         format_keyid (desc->u.kid, KF_SHORT, b, sizeof (b)));
     case KEYDB_SEARCH_MODE_LONG_KID:
       return xasprintf ("LONG_KID: '%s'",
                         format_keyid (desc->u.kid, KF_LONG, b, sizeof (b)));
     case KEYDB_SEARCH_MODE_FPR:
       bin2hex (desc->u.fpr, desc->fprlen, fpr);
       return xasprintf ("FPR%02d: '%s'", desc->fprlen,
                         format_hexfingerprint (fpr, b, sizeof (b)));
     case KEYDB_SEARCH_MODE_ISSUER:
       return xasprintf ("ISSUER: '%s'", desc->u.name);
     case KEYDB_SEARCH_MODE_ISSUER_SN:
       return xasprintf ("ISSUER_SN: '%*s'",
                         (int) (desc->snlen == -1
                                ? strlen (desc->sn) : desc->snlen),
                         desc->sn);
     case KEYDB_SEARCH_MODE_SN:
       return xasprintf ("SN: '%*s'",
                         (int) (desc->snlen == -1
                                ? strlen (desc->sn) : desc->snlen),
                         desc->sn);
     case KEYDB_SEARCH_MODE_SUBJECT:
       return xasprintf ("SUBJECT: '%s'", desc->u.name);
     case KEYDB_SEARCH_MODE_KEYGRIP:
-      return xasprintf ("KEYGRIP: %s", desc->u.grip);
+      bin2hex (desc[0].u.grip, 20, fpr);
+      return xasprintf ("KEYGRIP: %s", fpr);
+    case KEYDB_SEARCH_MODE_UBID:
+      bin2hex (desc[0].u.ubid, 20, fpr);
+      return xasprintf ("UBID: %s", fpr);
     case KEYDB_SEARCH_MODE_FIRST:
       return xasprintf ("FIRST");
     case KEYDB_SEARCH_MODE_NEXT:
       return xasprintf ("NEXT");
     default:
       return xasprintf ("Bad search mode (%d)", desc->mode);
     }
 }
 
 
 
 /* Register a resource (keyring or keybox).  The first keyring or
  * keybox that is added using this function is created if it does not
  * already exist and the KEYDB_RESOURCE_FLAG_READONLY is not set.
  *
  * FLAGS are a combination of the KEYDB_RESOURCE_FLAG_* constants.
  *
  * URL must have the following form:
  *
  *   gnupg-ring:filename  = plain keyring
  *   gnupg-kbx:filename   = keybox file
  *   filename             = check file's type (create as a plain keyring)
  *
  * Note: on systems with drive letters (Windows) invalid URLs (i.e.,
  * those with an unrecognized part before the ':' such as "c:\...")
  * will silently be treated as bare filenames.  On other systems, such
  * URLs will cause this function to return GPG_ERR_GENERAL.
  *
  * If KEYDB_RESOURCE_FLAG_DEFAULT is set, the resource is a keyring
  * and the file ends in ".gpg", then this function also checks if a
  * file with the same name, but the extension ".kbx" exists, is a
  * keybox and the OpenPGP flag is set.  If so, this function opens
  * that resource instead.
  *
  * If the file is not found, KEYDB_RESOURCE_FLAG_GPGVDEF is set and
  * the URL ends in ".kbx", then this function will try opening the
  * same URL, but with the extension ".gpg".  If that file is a keybox
  * with the OpenPGP flag set or it is a keyring, then we use that
  * instead.
  *
  * If the file is not found, KEYDB_RESOURCE_FLAG_DEFAULT is set, the
  * file should be created and the file's extension is ".gpg" then we
  * replace the extension with ".kbx".
  *
  * If the KEYDB_RESOURCE_FLAG_PRIMARY is set and the resource is a
  * keyring (not a keybox), then this resource is considered the
  * primary resource.  This is used by keydb_locate_writable().  If
  * another primary keyring is set, then that keyring is considered the
  * primary.
  *
  * If KEYDB_RESOURCE_FLAG_READONLY is set and the resource is a
  * keyring (not a keybox), then the keyring is marked as read only and
  * operations just as keyring_insert_keyblock will return
  * GPG_ERR_ACCESS.  */
 gpg_error_t
 keydb_add_resource (const char *url, unsigned int flags)
 {
   /* The file named by the URL (i.e., without the prototype).  */
   const char *resname = url;
 
   char *filename = NULL;
   int create;
   int read_only = !!(flags&KEYDB_RESOURCE_FLAG_READONLY);
   int is_default = !!(flags&KEYDB_RESOURCE_FLAG_DEFAULT);
   int is_gpgvdef = !!(flags&KEYDB_RESOURCE_FLAG_GPGVDEF);
   gpg_error_t err = 0;
   KeydbResourceType rt = KEYDB_RESOURCE_TYPE_NONE;
   void *token;
 
   /* Create the resource if it is the first registered one.  */
   create = (!read_only && !any_registered);
 
   if (strlen (resname) > 11 && !strncmp( resname, "gnupg-ring:", 11) )
     {
       rt = KEYDB_RESOURCE_TYPE_KEYRING;
       resname += 11;
     }
   else if (strlen (resname) > 10 && !strncmp (resname, "gnupg-kbx:", 10) )
     {
       rt = KEYDB_RESOURCE_TYPE_KEYBOX;
       resname += 10;
     }
 #if !defined(HAVE_DRIVE_LETTERS) && !defined(__riscos__)
   else if (strchr (resname, ':'))
     {
       log_error ("invalid key resource URL '%s'\n", url );
       err = gpg_error (GPG_ERR_GENERAL);
       goto leave;
     }
 #endif /* !HAVE_DRIVE_LETTERS && !__riscos__ */
 
   if (*resname != DIRSEP_C
 #ifdef HAVE_W32_SYSTEM
       && *resname != '/'  /* Fixme: does not handle drive letters.  */
 #endif
         )
     {
       /* Do tilde expansion etc. */
       if (strchr (resname, DIRSEP_C)
 #ifdef HAVE_W32_SYSTEM
           || strchr (resname, '/')  /* Windows also accepts this.  */
 #endif
           )
         filename = make_filename (resname, NULL);
       else
         filename = make_filename (gnupg_homedir (), resname, NULL);
     }
   else
     filename = xstrdup (resname);
 
   /* See whether we can determine the filetype.  */
   if (rt == KEYDB_RESOURCE_TYPE_NONE)
     {
       int found, openpgp_flag;
       int pass = 0;
       size_t filenamelen;
 
     check_again:
       filenamelen = strlen (filename);
       rt = rt_from_file (filename, &found, &openpgp_flag);
       if (found)
         {
           /* The file exists and we have the resource type in RT.
 
              Now let us check whether in addition to the "pubring.gpg"
              a "pubring.kbx with openpgp keys exists.  This is so that
              GPG 2.1 will use an existing "pubring.kbx" by default iff
              that file has been created or used by 2.1.  This check is
              needed because after creation or use of the kbx file with
              2.1 an older version of gpg may have created a new
              pubring.gpg for its own use.  */
           if (!pass && is_default && rt == KEYDB_RESOURCE_TYPE_KEYRING
               && filenamelen > 4 && !strcmp (filename+filenamelen-4, ".gpg"))
             {
               strcpy (filename+filenamelen-4, ".kbx");
               if ((rt_from_file (filename, &found, &openpgp_flag)
                    == KEYDB_RESOURCE_TYPE_KEYBOX) && found && openpgp_flag)
                 rt = KEYDB_RESOURCE_TYPE_KEYBOX;
               else /* Restore filename */
                 strcpy (filename+filenamelen-4, ".gpg");
             }
 	}
       else if (!pass && is_gpgvdef
                && filenamelen > 4 && !strcmp (filename+filenamelen-4, ".kbx"))
         {
           /* Not found but gpgv's default "trustedkeys.kbx" file has
              been requested.  We did not found it so now check whether
              a "trustedkeys.gpg" file exists and use that instead.  */
           KeydbResourceType rttmp;
 
           strcpy (filename+filenamelen-4, ".gpg");
           rttmp = rt_from_file (filename, &found, &openpgp_flag);
           if (found
               && ((rttmp == KEYDB_RESOURCE_TYPE_KEYBOX && openpgp_flag)
                   || (rttmp == KEYDB_RESOURCE_TYPE_KEYRING)))
             rt = rttmp;
           else /* Restore filename */
             strcpy (filename+filenamelen-4, ".kbx");
         }
       else if (!pass
                && is_default && create
                && filenamelen > 4 && !strcmp (filename+filenamelen-4, ".gpg"))
         {
           /* The file does not exist, the default resource has been
              requested, the file shall be created, and the file has a
              ".gpg" suffix.  Change the suffix to ".kbx" and try once
              more.  This way we achieve that we open an existing
              ".gpg" keyring, but create a new keybox file with an
              ".kbx" suffix.  */
           strcpy (filename+filenamelen-4, ".kbx");
           pass++;
           goto check_again;
         }
       else /* No file yet: create keybox. */
         rt = KEYDB_RESOURCE_TYPE_KEYBOX;
     }
 
   switch (rt)
     {
     case KEYDB_RESOURCE_TYPE_NONE:
       log_error ("unknown type of key resource '%s'\n", url );
       err = gpg_error (GPG_ERR_GENERAL);
       goto leave;
 
     case KEYDB_RESOURCE_TYPE_KEYRING:
       err = maybe_create_keyring_or_box (filename, 0, create);
       if (err)
         goto leave;
 
       if (keyring_register_filename (filename, read_only, &token))
         {
           if (used_resources >= MAX_KEYDB_RESOURCES)
             err = gpg_error (GPG_ERR_RESOURCE_LIMIT);
           else
             {
               if ((flags & KEYDB_RESOURCE_FLAG_PRIMARY))
                 primary_keydb = token;
               all_resources[used_resources].type = rt;
               all_resources[used_resources].u.kr = NULL; /* Not used here */
               all_resources[used_resources].token = token;
               used_resources++;
             }
         }
       else
         {
           /* This keyring was already registered, so ignore it.
              However, we can still mark it as primary even if it was
              already registered.  */
           if ((flags & KEYDB_RESOURCE_FLAG_PRIMARY))
             primary_keydb = token;
         }
       break;
 
     case KEYDB_RESOURCE_TYPE_KEYBOX:
       {
         err = maybe_create_keyring_or_box (filename, 1, create);
         if (err)
           goto leave;
 
         err = keybox_register_file (filename, 0, &token);
         if (!err)
           {
             if (used_resources >= MAX_KEYDB_RESOURCES)
               err = gpg_error (GPG_ERR_RESOURCE_LIMIT);
             else
               {
                 if ((flags & KEYDB_RESOURCE_FLAG_PRIMARY))
                   primary_keydb = token;
                 all_resources[used_resources].type = rt;
                 all_resources[used_resources].u.kb = NULL; /* Not used here */
                 all_resources[used_resources].token = token;
 
                 /* FIXME: Do a compress run if needed and no other
                    user is currently using the keybox. */
 
                 used_resources++;
               }
           }
         else if (gpg_err_code (err) == GPG_ERR_EEXIST)
           {
             /* Already registered.  We will mark it as the primary key
                if requested.  */
             if ((flags & KEYDB_RESOURCE_FLAG_PRIMARY))
               primary_keydb = token;
           }
       }
       break;
 
       default:
 	log_error ("resource type of '%s' not supported\n", url);
 	err = gpg_error (GPG_ERR_GENERAL);
 	goto leave;
     }
 
   /* fixme: check directory permissions and print a warning */
 
  leave:
   if (err)
     {
       log_error (_("keyblock resource '%s': %s\n"),
                  filename, gpg_strerror (err));
       write_status_error ("add_keyblock_resource", err);
     }
   else
     any_registered = 1;
   xfree (filename);
   return err;
 }
 
 
 void
 keydb_dump_stats (void)
 {
   log_info ("keydb: handles=%u locks=%u parse=%u get=%u\n",
             keydb_stats.handles,
             keydb_stats.locks,
             keydb_stats.parse_keyblocks,
             keydb_stats.get_keyblocks);
   log_info ("       build=%u update=%u insert=%u delete=%u\n",
             keydb_stats.build_keyblocks,
             keydb_stats.update_keyblocks,
             keydb_stats.insert_keyblocks,
             keydb_stats.delete_keyblocks);
   log_info ("       reset=%u found=%u not=%u cache=%u not=%u\n",
             keydb_stats.search_resets,
             keydb_stats.found,
             keydb_stats.notfound,
             keydb_stats.found_cached,
             keydb_stats.notfound_cached);
   log_info ("kid_not_found_cache: count=%u peak=%u flushes=%u\n",
             kid_not_found_stats.count,
             kid_not_found_stats.peak,
             kid_not_found_stats.flushes);
 }
 
 
 /* keydb_new diverts to here in non-keyboxd mode.  HD is just the
  * calloced structure with the handle type intialized.  */
 gpg_error_t
 internal_keydb_init (KEYDB_HANDLE hd)
 {
   gpg_error_t err = 0;
   int i, j;
   int die = 0;
   int reterrno;
 
   log_assert (!hd->use_keyboxd);
   hd->found = -1;
   hd->saved_found = -1;
   hd->is_reset = 1;
 
   log_assert (used_resources <= MAX_KEYDB_RESOURCES);
   for (i=j=0; ! die && i < used_resources; i++)
     {
       switch (all_resources[i].type)
         {
         case KEYDB_RESOURCE_TYPE_NONE: /* ignore */
           break;
         case KEYDB_RESOURCE_TYPE_KEYRING:
           hd->active[j].type   = all_resources[i].type;
           hd->active[j].token  = all_resources[i].token;
           hd->active[j].u.kr = keyring_new (all_resources[i].token);
           if (!hd->active[j].u.kr)
             {
               reterrno = errno;
               die = 1;
             }
           j++;
           break;
         case KEYDB_RESOURCE_TYPE_KEYBOX:
           hd->active[j].type   = all_resources[i].type;
           hd->active[j].token  = all_resources[i].token;
           hd->active[j].u.kb   = keybox_new_openpgp (all_resources[i].token, 0);
           if (!hd->active[j].u.kb)
             {
               reterrno = errno;
               die = 1;
             }
           j++;
           break;
         }
     }
   hd->used = j;
 
   active_handles++;
   keydb_stats.handles++;
 
   if (die)
     err = gpg_error_from_errno (reterrno);
 
    return err;
 }
 
 
 /* Free all non-keyboxd resources owned by the database handle.
  * keydb_release diverts to here.  */
 void
 internal_keydb_deinit (KEYDB_HANDLE hd)
 {
   int i;
 
   log_assert (!hd->use_keyboxd);
 
   log_assert (active_handles > 0);
   active_handles--;
 
   hd->keep_lock = 0;
   unlock_all (hd);
   for (i=0; i < hd->used; i++)
     {
       switch (hd->active[i].type)
         {
         case KEYDB_RESOURCE_TYPE_NONE:
           break;
         case KEYDB_RESOURCE_TYPE_KEYRING:
           keyring_release (hd->active[i].u.kr);
           break;
         case KEYDB_RESOURCE_TYPE_KEYBOX:
           keybox_release (hd->active[i].u.kb);
           break;
         }
     }
 
   keyblock_cache_clear (hd);
 }
 
 
 /* Take a lock on the files immediately and not only during insert or
  * update.  This lock is released with keydb_release.  */
 gpg_error_t
 internal_keydb_lock (KEYDB_HANDLE hd)
 {
   gpg_error_t err;
 
   log_assert (!hd->use_keyboxd);
 
   err = lock_all (hd);
   if (!err)
     hd->keep_lock = 1;
 
   return err;
 }
 
 
 /* Set a flag on the handle to suppress use of cached results.  This
  * is required for updating a keyring and for key listings.  Fixme:
  * Using a new parameter for keydb_new might be a better solution.  */
 void
 keydb_disable_caching (KEYDB_HANDLE hd)
 {
   if (hd && !hd->use_keyboxd)
     hd->no_caching = 1;
 }
 
 
 /* Return the file name of the resource in which the current search
  * result was found or, if there is no search result, the filename of
  * the current resource (i.e., the resource that the file position
  * points to).  Note: the filename is not necessarily the URL used to
  * open it!
  *
  * This function only returns NULL if no handle is specified, in all
  * other error cases an empty string is returned.  */
 const char *
 keydb_get_resource_name (KEYDB_HANDLE hd)
 {
   int idx;
   const char *s = NULL;
 
   if (!hd)
     return NULL;
 
   if (!hd->use_keyboxd)
     return "[keyboxd]";
 
   if ( hd->found >= 0 && hd->found < hd->used)
     idx = hd->found;
   else if ( hd->current >= 0 && hd->current < hd->used)
     idx = hd->current;
   else
     idx = 0;
 
   switch (hd->active[idx].type)
     {
     case KEYDB_RESOURCE_TYPE_NONE:
       s = NULL;
       break;
     case KEYDB_RESOURCE_TYPE_KEYRING:
       s = keyring_get_resource_name (hd->active[idx].u.kr);
       break;
     case KEYDB_RESOURCE_TYPE_KEYBOX:
       s = keybox_get_resource_name (hd->active[idx].u.kb);
       break;
     }
 
   return s? s: "";
 }
 
 
 
 static int
 lock_all (KEYDB_HANDLE hd)
 {
   int i, rc = 0;
 
   /* Fixme: This locking scheme may lead to a deadlock if the resources
      are not added in the same order by all processes.  We are
      currently only allowing one resource so it is not a problem.
      [Oops: Who claimed the latter]
 
      To fix this we need to use a lock file to protect lock_all.  */
 
   for (i=0; !rc && i < hd->used; i++)
     {
       switch (hd->active[i].type)
         {
         case KEYDB_RESOURCE_TYPE_NONE:
           break;
         case KEYDB_RESOURCE_TYPE_KEYRING:
           rc = keyring_lock (hd->active[i].u.kr, 1);
           break;
         case KEYDB_RESOURCE_TYPE_KEYBOX:
           rc = keybox_lock (hd->active[i].u.kb, 1, -1);
           break;
         }
     }
 
   if (rc)
     {
       /* Revert the already taken locks.  */
       for (i--; i >= 0; i--)
         {
           switch (hd->active[i].type)
             {
             case KEYDB_RESOURCE_TYPE_NONE:
               break;
             case KEYDB_RESOURCE_TYPE_KEYRING:
               keyring_lock (hd->active[i].u.kr, 0);
               break;
             case KEYDB_RESOURCE_TYPE_KEYBOX:
               keybox_lock (hd->active[i].u.kb, 0, 0);
               break;
             }
         }
     }
   else
     {
       hd->locked = 1;
       keydb_stats.locks++;
     }
 
   return rc;
 }
 
 
 static void
 unlock_all (KEYDB_HANDLE hd)
 {
   int i;
 
   if (!hd->locked || hd->keep_lock)
     return;
 
   for (i=hd->used-1; i >= 0; i--)
     {
       switch (hd->active[i].type)
         {
         case KEYDB_RESOURCE_TYPE_NONE:
           break;
         case KEYDB_RESOURCE_TYPE_KEYRING:
           keyring_lock (hd->active[i].u.kr, 0);
           break;
         case KEYDB_RESOURCE_TYPE_KEYBOX:
           keybox_lock (hd->active[i].u.kb, 0, 0);
           break;
         }
     }
   hd->locked = 0;
 }
 
 
 
 /* Save the last found state and invalidate the current selection
  * (i.e., the entry selected by keydb_search() is invalidated and
  * something like keydb_get_keyblock() will return an error).  This
  * does not change the file position.  This makes it possible to do
  * something like:
  *
  *   keydb_search (hd, ...);  // Result 1.
  *   keydb_push_found_state (hd);
  *     keydb_search_reset (hd);
  *     keydb_search (hd, ...);  // Result 2.
  *   keydb_pop_found_state (hd);
  *   keydb_get_keyblock (hd, ...);  // -> Result 1.
  *
  * Note: it is only possible to save a single save state at a time.
  * In other words, the save stack only has room for a single
  * instance of the state.  */
 /* FIXME(keyboxd): This function is used only at one place - see how
  * we can avoid it.  */
 void
 keydb_push_found_state (KEYDB_HANDLE hd)
 {
   if (!hd)
     return;
 
   if (hd->found < 0 || hd->found >= hd->used)
     {
       hd->saved_found = -1;
       return;
     }
 
   switch (hd->active[hd->found].type)
     {
     case KEYDB_RESOURCE_TYPE_NONE:
       break;
     case KEYDB_RESOURCE_TYPE_KEYRING:
       keyring_push_found_state (hd->active[hd->found].u.kr);
       break;
     case KEYDB_RESOURCE_TYPE_KEYBOX:
       keybox_push_found_state (hd->active[hd->found].u.kb);
       break;
     }
 
   hd->saved_found = hd->found;
   hd->found = -1;
 }
 
 
 /* Restore the previous save state.  If the saved state is NULL or
    invalid, this is a NOP.  */
 /* FIXME(keyboxd): This function is used only at one place - see how
  * we can avoid it.  */
 void
 keydb_pop_found_state (KEYDB_HANDLE hd)
 {
   if (!hd)
     return;
 
   hd->found = hd->saved_found;
   hd->saved_found = -1;
   if (hd->found < 0 || hd->found >= hd->used)
     return;
 
   switch (hd->active[hd->found].type)
     {
     case KEYDB_RESOURCE_TYPE_NONE:
       break;
     case KEYDB_RESOURCE_TYPE_KEYRING:
       keyring_pop_found_state (hd->active[hd->found].u.kr);
       break;
     case KEYDB_RESOURCE_TYPE_KEYBOX:
       keybox_pop_found_state (hd->active[hd->found].u.kb);
       break;
     }
 }
 
 
 
 static gpg_error_t
 parse_keyblock_image (iobuf_t iobuf, int pk_no, int uid_no,
                       kbnode_t *r_keyblock)
 {
   gpg_error_t err;
   struct parse_packet_ctx_s parsectx;
   PACKET *pkt;
   kbnode_t keyblock = NULL;
   kbnode_t node, *tail;
   int in_cert, save_mode;
   int pk_count, uid_count;
 
   *r_keyblock = NULL;
 
   pkt = xtrymalloc (sizeof *pkt);
   if (!pkt)
     return gpg_error_from_syserror ();
   init_packet (pkt);
   init_parse_packet (&parsectx, iobuf);
   save_mode = set_packet_list_mode (0);
   in_cert = 0;
   tail = NULL;
   pk_count = uid_count = 0;
   while ((err = parse_packet (&parsectx, pkt)) != -1)
     {
       if (gpg_err_code (err) == GPG_ERR_UNKNOWN_PACKET)
         {
           free_packet (pkt, &parsectx);
           init_packet (pkt);
           continue;
 	}
       if (err)
         {
           es_fflush (es_stdout);
           log_error ("parse_keyblock_image: read error: %s\n",
                      gpg_strerror (err));
           if (gpg_err_code (err) == GPG_ERR_INV_PACKET)
             {
               free_packet (pkt, &parsectx);
               init_packet (pkt);
               continue;
             }
           err = gpg_error (GPG_ERR_INV_KEYRING);
           break;
         }
 
       /* Filter allowed packets.  */
       switch (pkt->pkttype)
         {
         case PKT_PUBLIC_KEY:
         case PKT_PUBLIC_SUBKEY:
         case PKT_SECRET_KEY:
         case PKT_SECRET_SUBKEY:
         case PKT_USER_ID:
         case PKT_ATTRIBUTE:
         case PKT_SIGNATURE:
         case PKT_RING_TRUST:
           break; /* Allowed per RFC.  */
 
         default:
           log_info ("skipped packet of type %d in keybox\n", (int)pkt->pkttype);
           free_packet(pkt, &parsectx);
           init_packet(pkt);
           continue;
         }
 
       /* Other sanity checks.  */
       if (!in_cert && pkt->pkttype != PKT_PUBLIC_KEY)
         {
           log_error ("parse_keyblock_image: first packet in a keybox blob "
                      "is not a public key packet\n");
           err = gpg_error (GPG_ERR_INV_KEYRING);
           break;
         }
       if (in_cert && (pkt->pkttype == PKT_PUBLIC_KEY
                       || pkt->pkttype == PKT_SECRET_KEY))
         {
           log_error ("parse_keyblock_image: "
                      "multiple keyblocks in a keybox blob\n");
           err = gpg_error (GPG_ERR_INV_KEYRING);
           break;
         }
       in_cert = 1;
 
       node = new_kbnode (pkt);
 
       switch (pkt->pkttype)
         {
         case PKT_PUBLIC_KEY:
         case PKT_PUBLIC_SUBKEY:
         case PKT_SECRET_KEY:
         case PKT_SECRET_SUBKEY:
           if (++pk_count == pk_no)
             node->flag |= 1;
           break;
 
         case PKT_USER_ID:
           if (++uid_count == uid_no)
             node->flag |= 2;
           break;
 
         default:
           break;
         }
 
       if (!keyblock)
         keyblock = node;
       else
         *tail = node;
       tail = &node->next;
       pkt = xtrymalloc (sizeof *pkt);
       if (!pkt)
         {
           err = gpg_error_from_syserror ();
           break;
         }
       init_packet (pkt);
     }
   set_packet_list_mode (save_mode);
 
   if (err == -1 && keyblock)
     err = 0; /* Got the entire keyblock.  */
 
   if (err)
     release_kbnode (keyblock);
   else
     {
       *r_keyblock = keyblock;
       keydb_stats.parse_keyblocks++;
     }
   free_packet (pkt, &parsectx);
   deinit_parse_packet (&parsectx);
   xfree (pkt);
   return err;
 }
 
 
 /* Return the keyblock last found by keydb_search() in *RET_KB.
  * keydb_get_keyblock divert to here in the non-keyboxd mode.
  *
  * On success, the function returns 0 and the caller must free *RET_KB
  * using release_kbnode().  Otherwise, the function returns an error
  * code.
  *
  * The returned keyblock has the kbnode flag bit 0 set for the node
  * with the public key used to locate the keyblock or flag bit 1 set
  * for the user ID node.  */
 gpg_error_t
 internal_keydb_get_keyblock (KEYDB_HANDLE hd, KBNODE *ret_kb)
 {
   gpg_error_t err = 0;
 
   log_assert (!hd->use_keyboxd);
 
   if (hd->keyblock_cache.state == KEYBLOCK_CACHE_FILLED)
     {
       err = iobuf_seek (hd->keyblock_cache.iobuf, 0);
       if (err)
 	{
 	  log_error ("keydb_get_keyblock: failed to rewind iobuf for cache\n");
 	  keyblock_cache_clear (hd);
 	}
       else
 	{
 	  err = parse_keyblock_image (hd->keyblock_cache.iobuf,
 				      hd->keyblock_cache.pk_no,
 				      hd->keyblock_cache.uid_no,
 				      ret_kb);
 	  if (err)
 	    keyblock_cache_clear (hd);
 	  if (DBG_CLOCK)
 	    log_clock ("%s leave (cached mode)", __func__);
 	  return err;
 	}
     }
 
   if (hd->found < 0 || hd->found >= hd->used)
     return gpg_error (GPG_ERR_VALUE_NOT_FOUND);
 
   switch (hd->active[hd->found].type)
     {
     case KEYDB_RESOURCE_TYPE_NONE:
       err = gpg_error (GPG_ERR_GENERAL); /* oops */
       break;
     case KEYDB_RESOURCE_TYPE_KEYRING:
       err = keyring_get_keyblock (hd->active[hd->found].u.kr, ret_kb);
       break;
     case KEYDB_RESOURCE_TYPE_KEYBOX:
       {
         iobuf_t iobuf;
         int pk_no, uid_no;
 
         err = keybox_get_keyblock (hd->active[hd->found].u.kb,
                                    &iobuf, &pk_no, &uid_no);
         if (!err)
           {
             err = parse_keyblock_image (iobuf, pk_no, uid_no, ret_kb);
             if (!err && hd->keyblock_cache.state == KEYBLOCK_CACHE_PREPARED)
               {
                 hd->keyblock_cache.state     = KEYBLOCK_CACHE_FILLED;
                 hd->keyblock_cache.iobuf     = iobuf;
                 hd->keyblock_cache.pk_no     = pk_no;
                 hd->keyblock_cache.uid_no    = uid_no;
               }
             else
               {
                 iobuf_close (iobuf);
               }
           }
       }
       break;
     }
 
   if (hd->keyblock_cache.state != KEYBLOCK_CACHE_FILLED)
     keyblock_cache_clear (hd);
 
   if (!err)
     keydb_stats.get_keyblocks++;
 
   return err;
 }
 
 
 /* Build a keyblock image from KEYBLOCK.  Returns 0 on success and
  * only then stores a new iobuf object at R_IOBUF.  */
 static gpg_error_t
 build_keyblock_image (kbnode_t keyblock, iobuf_t *r_iobuf)
 {
   gpg_error_t err;
   iobuf_t iobuf;
   kbnode_t kbctx, node;
 
   *r_iobuf = NULL;
 
   iobuf = iobuf_temp ();
   for (kbctx = NULL; (node = walk_kbnode (keyblock, &kbctx, 0));)
     {
       /* Make sure to use only packets valid on a keyblock.  */
       switch (node->pkt->pkttype)
         {
         case PKT_PUBLIC_KEY:
         case PKT_PUBLIC_SUBKEY:
         case PKT_SIGNATURE:
         case PKT_USER_ID:
         case PKT_ATTRIBUTE:
         case PKT_RING_TRUST:
           break;
         default:
           continue;
         }
 
       err = build_packet_and_meta (iobuf, node->pkt);
       if (err)
         {
           iobuf_close (iobuf);
           return err;
         }
     }
 
   keydb_stats.build_keyblocks++;
   *r_iobuf = iobuf;
   return 0;
 }
 
 
 /* Update the keyblock KB (i.e., extract the fingerprint and find the
  * corresponding keyblock in the keyring).
  * keydb_update_keyblock diverts to here in the non-keyboxd mode.
  *
  * This doesn't do anything if --dry-run was specified.
  *
  * Returns 0 on success.  Otherwise, it returns an error code.  Note:
  * if there isn't a keyblock in the keyring corresponding to KB, then
  * this function returns GPG_ERR_VALUE_NOT_FOUND.
  *
  * This function selects the matching record and modifies the current
  * file position to point to the record just after the selected entry.
  * Thus, if you do a subsequent search using HD, you should first do a
  * keydb_search_reset.  Further, if the selected record is important,
  * you should use keydb_push_found_state and keydb_pop_found_state to
  * save and restore it.  */
 gpg_error_t
 internal_keydb_update_keyblock (ctrl_t ctrl, KEYDB_HANDLE hd, kbnode_t kb)
 {
   gpg_error_t err;
   PKT_public_key *pk;
   KEYDB_SEARCH_DESC desc;
   size_t len;
 
   log_assert (!hd->use_keyboxd);
   pk = kb->pkt->pkt.public_key;
 
   kid_not_found_flush ();
   keyblock_cache_clear (hd);
 
   if (opt.dry_run)
     return 0;
 
   err = lock_all (hd);
   if (err)
     return err;
 
 #ifdef USE_TOFU
   tofu_notice_key_changed (ctrl, kb);
 #endif
 
   memset (&desc, 0, sizeof (desc));
   fingerprint_from_pk (pk, desc.u.fpr, &len);
   if (len == 20 || len == 32)
     {
       desc.mode = KEYDB_SEARCH_MODE_FPR;
       desc.fprlen = len;
     }
   else
     log_bug ("%s: Unsupported key length: %zu\n", __func__, len);
 
   keydb_search_reset (hd);
   err = keydb_search (hd, &desc, 1, NULL);
   if (err)
     return gpg_error (GPG_ERR_VALUE_NOT_FOUND);
   log_assert (hd->found >= 0 && hd->found < hd->used);
 
   switch (hd->active[hd->found].type)
     {
     case KEYDB_RESOURCE_TYPE_NONE:
       err = gpg_error (GPG_ERR_GENERAL); /* oops */
       break;
     case KEYDB_RESOURCE_TYPE_KEYRING:
       err = keyring_update_keyblock (hd->active[hd->found].u.kr, kb);
       break;
     case KEYDB_RESOURCE_TYPE_KEYBOX:
       {
         iobuf_t iobuf;
 
         err = build_keyblock_image (kb, &iobuf);
         if (!err)
           {
             err = keybox_update_keyblock (hd->active[hd->found].u.kb,
                                           iobuf_get_temp_buffer (iobuf),
                                           iobuf_get_temp_length (iobuf));
             iobuf_close (iobuf);
           }
       }
       break;
     }
 
   unlock_all (hd);
   if (!err)
     keydb_stats.update_keyblocks++;
   return err;
 }
 
 
 /* Insert a keyblock into one of the underlying keyrings or keyboxes.
  * keydb_insert_keyblock diverts to here in the non-keyboxd mode.
  *
  * Be default, the keyring / keybox from which the last search result
  * came is used.  If there was no previous search result (or
  * keydb_search_reset was called), then the keyring / keybox where the
  * next search would start is used (i.e., the current file position).
  *
  * Note: this doesn't do anything if --dry-run was specified.
  *
  * Returns 0 on success.  Otherwise, it returns an error code.  */
 gpg_error_t
 internal_keydb_insert_keyblock (KEYDB_HANDLE hd, kbnode_t kb)
 {
   gpg_error_t err;
   int idx;
 
   log_assert (!hd->use_keyboxd);
 
   kid_not_found_flush ();
   keyblock_cache_clear (hd);
 
   if (opt.dry_run)
     return 0;
 
   if (hd->found >= 0 && hd->found < hd->used)
     idx = hd->found;
   else if (hd->current >= 0 && hd->current < hd->used)
     idx = hd->current;
   else
     return gpg_error (GPG_ERR_GENERAL);
 
   err = lock_all (hd);
   if (err)
     return err;
 
   switch (hd->active[idx].type)
     {
     case KEYDB_RESOURCE_TYPE_NONE:
       err = gpg_error (GPG_ERR_GENERAL); /* oops */
       break;
     case KEYDB_RESOURCE_TYPE_KEYRING:
       err = keyring_insert_keyblock (hd->active[idx].u.kr, kb);
       break;
     case KEYDB_RESOURCE_TYPE_KEYBOX:
       { /* We need to turn our kbnode_t list of packets into a proper
            keyblock first.  This is required by the OpenPGP key parser
            included in the keybox code.  Eventually we can change this
            kludge to have the caller pass the image.  */
         iobuf_t iobuf;
 
         err = build_keyblock_image (kb, &iobuf);
         if (!err)
           {
             err = keybox_insert_keyblock (hd->active[idx].u.kb,
                                           iobuf_get_temp_buffer (iobuf),
                                           iobuf_get_temp_length (iobuf));
             iobuf_close (iobuf);
           }
       }
       break;
     }
 
   unlock_all (hd);
   if (!err)
     keydb_stats.insert_keyblocks++;
   return err;
 }
 
 
 /* Delete the currently selected keyblock.  If you haven't done a
  * search yet on this database handle (or called keydb_search_reset),
  * then this will return an error.
  *
  * Returns 0 on success or an error code, if an error occurs.  */
 gpg_error_t
 internal_keydb_delete_keyblock (KEYDB_HANDLE hd)
 {
   gpg_error_t rc;
 
   log_assert (!hd->use_keyboxd);
 
   kid_not_found_flush ();
   keyblock_cache_clear (hd);
 
   if (hd->found < 0 || hd->found >= hd->used)
     return gpg_error (GPG_ERR_VALUE_NOT_FOUND);
 
   if (opt.dry_run)
     return 0;
 
   rc = lock_all (hd);
   if (rc)
     return rc;
 
   switch (hd->active[hd->found].type)
     {
     case KEYDB_RESOURCE_TYPE_NONE:
       rc = gpg_error (GPG_ERR_GENERAL);
       break;
     case KEYDB_RESOURCE_TYPE_KEYRING:
       rc = keyring_delete_keyblock (hd->active[hd->found].u.kr);
       break;
     case KEYDB_RESOURCE_TYPE_KEYBOX:
       rc = keybox_delete (hd->active[hd->found].u.kb);
       break;
     }
 
   unlock_all (hd);
   if (!rc)
     keydb_stats.delete_keyblocks++;
   return rc;
 }
 
 
 
 /* A database may consists of multiple keyrings / key boxes.  This
  * sets the "file position" to the start of the first keyring / key
  * box that is writable (i.e., doesn't have the read-only flag set).
  *
  * This first tries the primary keyring (the last keyring (not
  * keybox!) added using keydb_add_resource() and with
  * KEYDB_RESOURCE_FLAG_PRIMARY set).  If that is not writable, then it
  * tries the keyrings / keyboxes in the order in which they were
  * added.  */
 gpg_error_t
 keydb_locate_writable (KEYDB_HANDLE hd)
 {
   gpg_error_t rc;
 
   if (!hd)
     return GPG_ERR_INV_ARG;
 
   if (hd->use_keyboxd)
     return 0;  /* No need for this here.  */
 
   rc = keydb_search_reset (hd); /* this does reset hd->current */
   if (rc)
     return rc;
 
   /* If we have a primary set, try that one first */
   if (primary_keydb)
     {
       for ( ; hd->current >= 0 && hd->current < hd->used; hd->current++)
 	{
 	  if(hd->active[hd->current].token == primary_keydb)
 	    {
 	      if(keyring_is_writable (hd->active[hd->current].token))
 		return 0;
 	      else
 		break;
 	    }
 	}
 
       rc = keydb_search_reset (hd); /* this does reset hd->current */
       if (rc)
 	return rc;
     }
 
   for ( ; hd->current >= 0 && hd->current < hd->used; hd->current++)
     {
       switch (hd->active[hd->current].type)
         {
         case KEYDB_RESOURCE_TYPE_NONE:
           BUG();
           break;
         case KEYDB_RESOURCE_TYPE_KEYRING:
           if (keyring_is_writable (hd->active[hd->current].token))
             return 0; /* found (hd->current is set to it) */
           break;
         case KEYDB_RESOURCE_TYPE_KEYBOX:
           if (keybox_is_writable (hd->active[hd->current].token))
             return 0; /* found (hd->current is set to it) */
           break;
         }
     }
 
   return gpg_error (GPG_ERR_NOT_FOUND);
 }
 
 
 /* Rebuild the on-disk caches of all key resources.  */
 void
 keydb_rebuild_caches (ctrl_t ctrl, int noisy)
 {
   int i, rc;
 
   if (opt.use_keyboxd)
     return;  /* No need for this here.  */
 
   for (i=0; i < used_resources; i++)
     {
       if (!keyring_is_writable (all_resources[i].token))
         continue;
       switch (all_resources[i].type)
         {
         case KEYDB_RESOURCE_TYPE_NONE: /* ignore */
           break;
         case KEYDB_RESOURCE_TYPE_KEYRING:
           rc = keyring_rebuild_cache (ctrl, all_resources[i].token,noisy);
           if (rc)
             log_error (_("failed to rebuild keyring cache: %s\n"),
                        gpg_strerror (rc));
           break;
         case KEYDB_RESOURCE_TYPE_KEYBOX:
           /* N/A.  */
           break;
         }
     }
 }
 
 
 /* Return the number of skipped blocks (because they were too large to
    read from a keybox) since the last search reset.  */
 unsigned long
 keydb_get_skipped_counter (KEYDB_HANDLE hd)
 {
   /*FIXME(keyboxd): Do we need this?  */
   return hd && !hd->use_keyboxd? hd->skipped_long_blobs : 0;
 }
 
 
 /* Clears the current search result and resets the handle's position
  * so that the next search starts at the beginning of the database
  * (the start of the first resource).
  * keydb_search_reset diverts to here in the non-keyboxd mode.
  *
  * Returns 0 on success and an error code if an error occurred.
  * (Currently, this function always returns 0 if HD is valid.)  */
 gpg_error_t
 internal_keydb_search_reset (KEYDB_HANDLE hd)
 {
   gpg_error_t rc = 0;
   int i;
 
   log_assert (!hd->use_keyboxd);
 
   keyblock_cache_clear (hd);
 
   hd->skipped_long_blobs = 0;
   hd->current = 0;
   hd->found = -1;
   /* Now reset all resources.  */
   for (i=0; !rc && i < hd->used; i++)
     {
       switch (hd->active[i].type)
         {
         case KEYDB_RESOURCE_TYPE_NONE:
           break;
         case KEYDB_RESOURCE_TYPE_KEYRING:
           rc = keyring_search_reset (hd->active[i].u.kr);
           break;
         case KEYDB_RESOURCE_TYPE_KEYBOX:
           rc = keybox_search_reset (hd->active[i].u.kb);
           break;
         }
     }
   hd->is_reset = 1;
   if (!rc)
     keydb_stats.search_resets++;
   return rc;
 }
 
 
 /* Search the database for keys matching the search description.  If
  * the DB contains any legacy keys, these are silently ignored.
  * keydb_search diverts to here in the non-keyboxd mode.
  *
  * DESC is an array of search terms with NDESC entries.  The search
  * terms are or'd together.  That is, the next entry in the DB that
  * matches any of the descriptions will be returned.
  *
  * Note: this function resumes searching where the last search left
  * off (i.e., at the current file position).  If you want to search
  * from the start of the database, then you need to first call
  * keydb_search_reset().
  *
  * If no key matches the search description, returns
  * GPG_ERR_NOT_FOUND.  If there was a match, returns 0.  If an error
  * occurred, returns an error code.
  *
  * The returned key is considered to be selected and the raw data can,
  * for instance, be returned by calling keydb_get_keyblock().  */
 gpg_error_t
 internal_keydb_search (KEYDB_HANDLE hd, KEYDB_SEARCH_DESC *desc,
                        size_t ndesc, size_t *descindex)
 {
   gpg_error_t rc;
   int was_reset = hd->is_reset;
   /* If an entry is already in the cache, then don't add it again.  */
   int already_in_cache = 0;
   int fprlen;
 
   log_assert (!hd->use_keyboxd);
 
   if (!any_registered)
     {
       write_status_error ("keydb_search", gpg_error (GPG_ERR_KEYRING_OPEN));
       return gpg_error (GPG_ERR_NOT_FOUND);
     }
 
   if (ndesc == 1 && desc[0].mode == KEYDB_SEARCH_MODE_LONG_KID
       && (already_in_cache = kid_not_found_p (desc[0].u.kid)) == 1 )
     {
       if (DBG_CLOCK)
         log_clock ("%s leave (not found, cached)", __func__);
       keydb_stats.notfound_cached++;
       return gpg_error (GPG_ERR_NOT_FOUND);
     }
 
   /* NB: If one of the exact search modes below is used in a loop to
      walk over all keys (with the same fingerprint) the caching must
      have been disabled for the handle.  */
   if (desc[0].mode == KEYDB_SEARCH_MODE_FPR)
     fprlen = desc[0].fprlen;
   else
     fprlen = 0;
 
   if (!hd->no_caching
       && ndesc == 1
       && fprlen
       && hd->keyblock_cache.state == KEYBLOCK_CACHE_FILLED
       && hd->keyblock_cache.fprlen == fprlen
       && !memcmp (hd->keyblock_cache.fpr, desc[0].u.fpr, fprlen)
       /* Make sure the current file position occurs before the cached
          result to avoid an infinite loop.  */
       && (hd->current < hd->keyblock_cache.resource
           || (hd->current == hd->keyblock_cache.resource
               && (keybox_offset (hd->active[hd->current].u.kb)
                   <= hd->keyblock_cache.offset))))
     {
       /* (DESCINDEX is already set).  */
       if (DBG_CLOCK)
         log_clock ("%s leave (cached)", __func__);
 
       hd->current = hd->keyblock_cache.resource;
       /* HD->KEYBLOCK_CACHE.OFFSET is the last byte in the record.
          Seek just beyond that.  */
       keybox_seek (hd->active[hd->current].u.kb, hd->keyblock_cache.offset + 1);
       keydb_stats.found_cached++;
       return 0;
     }
 
   rc = -1;
   while ((rc == -1 || gpg_err_code (rc) == GPG_ERR_EOF)
          && hd->current >= 0 && hd->current < hd->used)
     {
       if (DBG_LOOKUP)
         log_debug ("%s: searching %s (resource %d of %d)\n",
                    __func__,
                    hd->active[hd->current].type == KEYDB_RESOURCE_TYPE_KEYRING
                    ? "keyring"
                    : (hd->active[hd->current].type == KEYDB_RESOURCE_TYPE_KEYBOX
                       ? "keybox" : "unknown type"),
                    hd->current, hd->used);
 
        switch (hd->active[hd->current].type)
         {
         case KEYDB_RESOURCE_TYPE_NONE:
           BUG(); /* we should never see it here */
           break;
         case KEYDB_RESOURCE_TYPE_KEYRING:
           rc = keyring_search (hd->active[hd->current].u.kr, desc,
                                ndesc, descindex, 1);
           break;
         case KEYDB_RESOURCE_TYPE_KEYBOX:
           do
             rc = keybox_search (hd->active[hd->current].u.kb, desc,
                                 ndesc, KEYBOX_BLOBTYPE_PGP,
                                 descindex, &hd->skipped_long_blobs);
           while (rc == GPG_ERR_LEGACY_KEY);
           break;
         }
 
       if (DBG_LOOKUP)
         log_debug ("%s: searched %s (resource %d of %d) => %s\n",
                    __func__,
                    hd->active[hd->current].type == KEYDB_RESOURCE_TYPE_KEYRING
                    ? "keyring"
                    : (hd->active[hd->current].type == KEYDB_RESOURCE_TYPE_KEYBOX
                       ? "keybox" : "unknown type"),
                    hd->current, hd->used,
                    rc == -1 ? "EOF" : gpg_strerror (rc));
 
       if (rc == -1 || gpg_err_code (rc) == GPG_ERR_EOF)
         {
           /* EOF -> switch to next resource */
           hd->current++;
         }
       else if (!rc)
         hd->found = hd->current;
     }
   hd->is_reset = 0;
 
   rc = ((rc == -1 || gpg_err_code (rc) == GPG_ERR_EOF)
         ? gpg_error (GPG_ERR_NOT_FOUND)
         : rc);
 
   keyblock_cache_clear (hd);
   if (!hd->no_caching
       && !rc
       && ndesc == 1
       && fprlen
       && hd->active[hd->current].type == KEYDB_RESOURCE_TYPE_KEYBOX)
     {
       hd->keyblock_cache.state = KEYBLOCK_CACHE_PREPARED;
       hd->keyblock_cache.resource = hd->current;
       /* The current offset is at the start of the next record.  Since
          a record is at least 1 byte, we just use offset - 1, which is
          within the record.  */
       hd->keyblock_cache.offset
         = keybox_offset (hd->active[hd->current].u.kb) - 1;
       memcpy (hd->keyblock_cache.fpr, desc[0].u.fpr, fprlen);
       hd->keyblock_cache.fprlen = fprlen;
     }
 
   if (gpg_err_code (rc) == GPG_ERR_NOT_FOUND
       && ndesc == 1
       && desc[0].mode == KEYDB_SEARCH_MODE_LONG_KID
       && was_reset
       && !already_in_cache)
     kid_not_found_insert (desc[0].u.kid);
 
   if (!rc)
     keydb_stats.found++;
   else
     keydb_stats.notfound++;
   return rc;
 }
 
 
 /* Return the first non-legacy key in the database.
  *
  * If you want the very first key in the database, you can directly
  * call keydb_search with the search description
  *  KEYDB_SEARCH_MODE_FIRST.  */
 gpg_error_t
 keydb_search_first (KEYDB_HANDLE hd)
 {
   gpg_error_t err;
   KEYDB_SEARCH_DESC desc;
 
   err = keydb_search_reset (hd);
   if (err)
     return err;
 
   memset (&desc, 0, sizeof desc);
   desc.mode = KEYDB_SEARCH_MODE_FIRST;
   return keydb_search (hd, &desc, 1, NULL);
 }
 
 
 /* Return the next key (not the next matching key!).
  *
  * Unlike calling keydb_search with KEYDB_SEARCH_MODE_NEXT, this
  * function silently skips legacy keys.  */
 gpg_error_t
 keydb_search_next (KEYDB_HANDLE hd)
 {
   KEYDB_SEARCH_DESC desc;
 
   memset (&desc, 0, sizeof desc);
   desc.mode = KEYDB_SEARCH_MODE_NEXT;
   return keydb_search (hd, &desc, 1, NULL);
 }
 
 
 /* This is a convenience function for searching for keys with a long
  * key id.
  *
  * Note: this function resumes searching where the last search left
  * off.  If you want to search the whole database, then you need to
  * first call keydb_search_reset().  */
 gpg_error_t
 keydb_search_kid (KEYDB_HANDLE hd, u32 *kid)
 {
   KEYDB_SEARCH_DESC desc;
 
   memset (&desc, 0, sizeof desc);
   desc.mode = KEYDB_SEARCH_MODE_LONG_KID;
   desc.u.kid[0] = kid[0];
   desc.u.kid[1] = kid[1];
   return keydb_search (hd, &desc, 1, NULL);
 }
 
 
 /* This is a convenience function for searching for keys with a long
  * (20 byte) fingerprint.
  *
  * Note: this function resumes searching where the last search left
  * off.  If you want to search the whole database, then you need to
  * first call keydb_search_reset().  */
 gpg_error_t
 keydb_search_fpr (KEYDB_HANDLE hd, const byte *fpr, size_t fprlen)
 {
   KEYDB_SEARCH_DESC desc;
 
   memset (&desc, 0, sizeof desc);
   desc.mode = KEYDB_SEARCH_MODE_FPR;
   memcpy (desc.u.fpr, fpr, fprlen);
   desc.fprlen = fprlen;
   return keydb_search (hd, &desc, 1, NULL);
 }
diff --git a/kbx/backend-cache.c b/kbx/backend-cache.c
index d5b46b50a..10a6f6bd9 100644
--- a/kbx/backend-cache.c
+++ b/kbx/backend-cache.c
@@ -1,1167 +1,1190 @@
 /* backend-cache.c - Cache backend for keyboxd
  * Copyright (C) 2019 g10 Code GmbH
  *
  * This file is part of GnuPG.
  *
  * GnuPG 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 3 of the License, or
  * (at your option) any later version.
  *
  * GnuPG 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 this program; if not, see <https://www.gnu.org/licenses/>.
  * SPDX-License-Identifier: GPL-3.0-or-later
  */
 
 /*
  * This cache backend is designed to be queried first and to deliver
  * cached items (which may also be not-found).  A set a maintenance
  * functions is used used by the frontend to fill the cache.
  * FIXME: Support x.509
  */
 
 #include <config.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <stddef.h>
 #include <string.h>
 
 #include "keyboxd.h"
 #include "../common/i18n.h"
 #include "../common/host2net.h"
 #include "backend.h"
 #include "keybox-defs.h"
 
 
 /* Standard values for the number of buckets and the threshold we use
  * to flush items.  */
 #define NO_OF_KEY_ITEM_BUCKETS          383
 #define KEY_ITEMS_PER_BUCKET_THRESHOLD  40
 #define NO_OF_BLOB_BUCKETS              383
 #define BLOBS_PER_BUCKET_THRESHOLD      20
 
 
 /* Our definition of the backend handle.  */
 struct backend_handle_s
 {
   enum database_types db_type; /* Always DB_TYPE_CACHE.  */
   unsigned int backend_id;     /* Always the id the backend.  */
 };
 
 
 /* The object holding a blob.  */
 typedef struct blob_s
 {
   struct blob_s *next;
   enum pubkey_types pktype;
   unsigned int refcount;
   unsigned int usecount;
   unsigned int datalen;
   unsigned char *data;        /* The actual data of length DATALEN.  */
   unsigned char ubid[20];
 } *blob_t;
 
 
 static blob_t *blob_table;                /* Hash table with the blobs.   */
 static size_t blob_table_size;            /* Number of allocated buckets. */
 static unsigned int blob_table_threshold; /* Max. # of items per bucket.  */
 static unsigned int blob_table_added;     /* Number of items added.       */
 static unsigned int blob_table_dropped;   /* Number of items dropped.     */
 static blob_t blob_attic;                 /* List of freed blobs.         */
 
 
 /* A list item to blob data.  This is so that a next operation on a
  * cached key item can actually work.  Things are complicated because
  * we do not want to force caching all object before we get a next
  * request from the client.  To accomplish this we keep a flag
  * indicating that the search needs to continue instead of delivering
  * the previous item from the cache.  */
 typedef struct bloblist_s
 {
   struct bloblist_s *next;
   unsigned int final_kid:1;     /* The final blob for KID searches. */
   unsigned int final_fpr:1;     /* The final blob for FPR searches. */
   unsigned int ubid_valid:1;    /* The blobid below is valid.   */
   unsigned int subkey:1;        /* The entry is for a subkey.   */
   unsigned int fprlen:8;        /* The length of the fingerprint or 0.  */
   char fpr[32];                 /* The buffer for the fingerprint.  */
   unsigned char ubid[20];       /* The Unique-Blob-ID of the blob.  */
 } *bloblist_t;
 
 static bloblist_t bloblist_attic;  /* List of freed items.  */
 
 /* The cache object.  For indexing we could use the fingerprint
  * directly as a hash value.  However, we use the keyid instead
  * because the keyid is used by OpenPGP in encrypted packets and older
  * signatures to identify a key.  Since v4 OpenPGP keys the keyid is
  * anyway a part of the fingerprint so it quickly extracted from a
  * fingerprint.  Note that v3 keys are not supported by gpg.
  * FIXME: Add support for X.509.
  */
 typedef struct key_item_s
 {
   struct key_item_s *next;
   bloblist_t  blist;       /* List of blobs or NULL for not-found.  */
   unsigned int usecount;
   unsigned int refcount;   /* Reference counter for this item.  */
   u32 kid_h;               /* Upper 4 bytes of the keyid.  */
   u32 kid_l;               /* Lower 4 bytes of the keyid.  */
 } *key_item_t;
 
 static key_item_t *key_table;            /* Hash table with the keys.    */
 static size_t key_table_size;            /* Number of allocated buckets. */
 static unsigned int key_table_threshold; /* Max. # of items per bucket.  */
 static unsigned int key_table_added;     /* Number of items added.       */
 static unsigned int key_table_dropped;   /* Number of items dropped.     */
 static key_item_t key_item_attic;        /* List of freed items.         */
 
 
 
 
 /* The hash function we use for the key_table.  Must not call a system
  * function.  */
 static inline unsigned int
 blob_table_hasher (const unsigned char *ubid)
 {
   return (ubid[0] << 16 | ubid[1]) % blob_table_size;
 }
 
 
 /* Runtime allocation of the key table.  This allows us to eventually
  * add an option to control the size.  */
 static gpg_error_t
 blob_table_init (void)
 {
   if (blob_table)
     return 0;
   blob_table_size = NO_OF_BLOB_BUCKETS;
   blob_table_threshold  = BLOBS_PER_BUCKET_THRESHOLD;
   blob_table = xtrycalloc (blob_table_size, sizeof *blob_table);
   if (!blob_table)
     return gpg_error_from_syserror ();
   return 0;
 }
 
 /* Free a blob.  This is done by moving it to the attic list.  */
 static void
 blob_unref (blob_t blob)
 {
   void *p;
 
   if (!blob)
     return;
   log_assert (blob->refcount);
   if (!--blob->refcount)
     {
       p = blob->data;
       blob->data = NULL;
       blob->next = blob_attic;
       blob_attic = blob;
       xfree (p);
     }
 }
 
 
 /* Given the hash value and the ubid, find the blob in the bucket.
  * Returns NULL if not found or the blob item if found.  Always
  * returns the the number of items searched, which is in the case of a
  * not-found the length of the chain.  */
 static blob_t
 find_blob (unsigned int hash, const unsigned char *ubid,
            unsigned int *r_count)
 {
   blob_t b;
   unsigned int count = 0;
 
   for (b = blob_table[hash]; b; b = b->next, count++)
     if (!memcmp (b->ubid, ubid, 20))
       break;
   if (r_count)
     *r_count = count;
   return b;
 }
 
 
 /* Helper for the qsort in key_table_put.  */
 static int
 compare_blobs (const void *arg_a, const void *arg_b)
 {
   const blob_t a = *(const blob_t *)arg_a;
   const blob_t b = *(const blob_t *)arg_b;
 
   /* Reverse sort on the usecount.  */
   if (a->usecount > b->usecount)
     return -1;
   else if (a->usecount == b->usecount)
     return 0;
   else
     return 1;
 }
 
 
 /* Put the blob (BLOBDATA, BLOBDATALEN) into the cache using UBID as
  * the index.  If it is already in the cache nothing happens.  */
 static void
-blob_table_put (const unsigned char *ubid,
+blob_table_put (const unsigned char *ubid, enum pubkey_types pktype,
                 const void *blobdata, unsigned int blobdatalen)
 {
   unsigned int hash;
   blob_t b;
   unsigned int count, n;
   void *blobdatacopy = NULL;
 
   hash = blob_table_hasher (ubid);
  find_again:
   b = find_blob (hash, ubid, &count);
   if (b)
     {
       xfree (blobdatacopy);
       return;  /* Already got this blob.  */
     }
 
   /* Create a copy of the blob if not yet done.  */
   if (!blobdatacopy)
     {
       blobdatacopy = xtrymalloc (blobdatalen);
       if (!blobdatacopy)
         {
           log_info ("Note: malloc failed while copying blob to the cache: %s\n",
                     gpg_strerror (gpg_error_from_syserror ()));
           return;  /* Out of core - ignore.  */
         }
       memcpy (blobdatacopy, blobdata, blobdatalen);
     }
 
   /* If the bucket is full remove a couple of items. */
   if (count >= blob_table_threshold)
     {
       blob_t list_head, *list_tailp, b_next;
       blob_t *array;
       int narray, idx;
 
       /* Unlink from the global list so that other threads don't
        * disturb us.  If another thread adds or removes something only
        * one will be the winner.  Bad luck for the dropped cache items
        * but after all it is just a cache.  */
       list_head = blob_table[hash];
       blob_table[hash] = NULL;
 
       /* Put all items into an array for sorting.  */
       array = xtrycalloc (count, sizeof *array);
       if (!array)
         {
           /* That's bad; give up all  items of the bucket.  */
           log_info ("Note: malloc failed while purging blobs from the "
                     "cache: %s\n", gpg_strerror (gpg_error_from_syserror ()));
           goto leave_drop;
         }
       narray = 0;
       for (b = list_head; b; b = b_next)
         {
           b_next = b->next;
           array[narray++] = b;
           b->next = NULL;
         }
       log_assert (narray == count);
 
       /* Sort the array and put half of it onto a new list.  */
       qsort (array, narray, sizeof *array, compare_blobs);
       list_head = NULL;
       list_tailp = &list_head;
       for (idx=0; idx < narray/2; idx++)
         {
           *list_tailp = array[idx];
           list_tailp = &array[idx]->next;
         }
 
       /* Put the new list into the bucket.  */
       b = blob_table[hash];
       blob_table[hash] = list_head;
       list_head = b;
 
       /* Free the remaining items and the array.  */
       for (; idx < narray; idx++)
         {
           blob_unref (array[idx]);
           blob_table_dropped++;
         }
       xfree (array);
 
     leave_drop:
       /* Free any items added in the meantime by other threads.  This
        * is also used in case of a malloc problem (which won't update
        * the counters, though). */
       for ( ; list_head; list_head = b_next)
         {
           b_next = list_head->next;
           blob_unref (list_head);
         }
     }
 
   /* Add an item to the bucket.  We allocate a whole block of items
    * for cache performance reasons.  */
   if (!blob_attic)
     {
       blob_t b_block;
       int b_blocksize = 256;
 
       b_block = xtrymalloc (b_blocksize * sizeof *b_block);
       if (!b_block)
         {
           log_info ("Note: malloc failed while adding blob to the cache: %s\n",
                     gpg_strerror (gpg_error_from_syserror ()));
           xfree (blobdatacopy);
           return;  /* Out of core - ignore.  */
         }
       for (n = 0; n < b_blocksize; n++)
         {
           b = b_block + n;
           b->next = blob_attic;
           blob_attic = b;
         }
 
       /* During the malloc another thread might have changed the
        * bucket.  Thus we need to start over.  */
       goto find_again;
     }
 
   /* We now know that there is an item in the attic.  Put it into the
    * chain.  Note that we may not use any system call here. */
   b = blob_attic;
   blob_attic = b->next;
   b->next = NULL;
+  b->pktype = pktype;
   b->data = blobdatacopy;
   b->datalen = blobdatalen;
   memcpy (b->ubid, ubid, 20);
   b->usecount = 1;
   b->refcount = 1;
   b->next = blob_table[hash];
   blob_table[hash] = b;
   blob_table_added++;
 }
 
 
 /* Given the UBID return a cached blob item.  The caller must
  * release that item using blob_unref.  */
 static blob_t
 blob_table_get (const unsigned char *ubid)
 {
   unsigned int hash;
   blob_t b;
 
   hash = blob_table_hasher (ubid);
   b = find_blob (hash, ubid, NULL);
   if (b)
     {
       b->usecount++;
       b->refcount++;
       return b;  /* Found  */
     }
 
   return NULL;
 }
 
 
 
 /* The hash function we use for the key_table.  Must not call a system
  * function.  */
 static inline unsigned int
 key_table_hasher (u32 kid_l)
 {
   return kid_l % key_table_size;
 }
 
 
 /* Runtime allocation of the key table.  This allows us to eventually
  * add an option to control the size.  */
 static gpg_error_t
 key_table_init (void)
 {
   if (key_table)
     return 0;
   key_table_size = NO_OF_KEY_ITEM_BUCKETS;
   key_table_threshold  = KEY_ITEMS_PER_BUCKET_THRESHOLD;
   key_table = xtrycalloc (key_table_size, sizeof *key_table);
   if (!key_table)
     return gpg_error_from_syserror ();
   return 0;
 }
 
 /* Free a key_item.  This is done by moving it to the attic list.  */
 static void
 key_item_unref (key_item_t ki)
 {
   bloblist_t bl, bl2;
 
   if (!ki)
     return;
   log_assert (ki->refcount);
   if (!--ki->refcount)
     {
       bl = ki->blist;
       ki->blist = NULL;
       ki->next = key_item_attic;
       key_item_attic = ki;
 
       if (bl)
         {
           for (bl2 = bl; bl2->next; bl2 = bl2->next)
             ;
           bl2->next = bloblist_attic;
           bloblist_attic = bl;
         }
     }
 }
 
 
 /* Given the hash value and the search info, find the key item in the
  * bucket.  Return NULL if not found or the key item if fount.  Always
  * returns the the number of items searched, which is in the case of a
  * not-found the length of the chain.  Note that FPR may only be NULL
  * if FPRLEN is 0. */
 static key_item_t
 find_in_chain (unsigned int hash, u32 kid_h, u32 kid_l,
                unsigned int *r_count)
 {
   key_item_t ki = key_table[hash];
   unsigned int count = 0;
 
   for (; ki; ki = ki->next, count++)
     if (ki->kid_h == kid_h && ki->kid_l == kid_l)
       break;
   if (r_count)
     *r_count = count;
   return ki;
 }
 
 
 /* Helper for the qsort in key_table_put.  */
 static int
 compare_key_items (const void *arg_a, const void *arg_b)
 {
   const key_item_t a = *(const key_item_t *)arg_a;
   const key_item_t b = *(const key_item_t *)arg_b;
 
   /* Reverse sort on the usecount.  */
   if (a->usecount > b->usecount)
     return -1;
   else if (a->usecount == b->usecount)
     return 0;
   else
     return 1;
 }
 
 
 /* Allocate new key items.  They are put to the attic so that the
  * caller can take them from there.  On allocation failure a note
  * is printed and an error returned.  */
 static gpg_error_t
 alloc_more_key_items (void)
 {
   gpg_error_t err;
   key_item_t kiblock, ki;
   int kiblocksize = 256;
   unsigned int n;
 
   kiblock = xtrymalloc (kiblocksize * sizeof *kiblock);
   if (!kiblock)
     {
       err = gpg_error_from_syserror ();
       log_info ("Note: malloc failed while adding to the cache: %s\n",
                 gpg_strerror (err));
       return err;
     }
   for (n = 0; n < kiblocksize; n++)
     {
       ki = kiblock + n;
       ki->next = key_item_attic;
       key_item_attic = ki;
     }
   return 0;
 }
 
 
 /* Allocate new bloblist items.  They are put to the attic so that the
  * caller can take them from there.  On allocation failure a note is
  * printed and an error returned.  */
 static gpg_error_t
 alloc_more_bloblist_items (void)
 {
   gpg_error_t err;
   bloblist_t bl;
   bloblist_t blistblock;
   int blistblocksize = 256;
   unsigned int n;
 
   blistblock = xtrymalloc (blistblocksize * sizeof *blistblock);
   if (!blistblock)
     {
       err = gpg_error_from_syserror ();
       log_info ("Note: malloc failed while adding to the cache: %s\n",
                 gpg_strerror (err));
       return err;
     }
   for (n = 0; n < blistblocksize; n++)
     {
       bl = blistblock + n;
       bl->next = bloblist_attic;
       bloblist_attic = bl;
     }
   return 0;
 }
 
 
 /* Helper for key_table_put.  This function assumes that
  * bloblist_attaci is not NULL.  Returns a new bloblist item.  Be
  * aware that no system calls may be done - even not log
  * functions!  */
 static bloblist_t
 new_bloblist_item (const unsigned char *fpr, unsigned int fprlen,
                    const unsigned char *ubid, int subkey)
 {
   bloblist_t bl;
 
   bl = bloblist_attic;
   bloblist_attic = bl->next;
   bl->next = NULL;
 
   if (ubid)
     memcpy (bl->ubid, ubid, 20);
   else
     memset (bl->ubid, 0, 20);
   bl->ubid_valid = 1;
   bl->final_kid = 0;
   bl->final_fpr = 0;
   bl->subkey = !!subkey;
   bl->fprlen = fprlen;
   memcpy (bl->fpr, fpr, fprlen);
   return bl;
 }
 
 
 /* If the list of key item in the bucken HASH is full remove a couple
  * of them.  On error a diagnostic is printed and an error code
  * return.  Note that the error code GPG_ERR_TRUE is returned if any
  * flush and thus system calls were done.
  */
 static gpg_error_t
 maybe_flush_some_key_buckets (unsigned int hash, unsigned int count)
 {
   gpg_error_t err;
   key_item_t ki, list_head, *list_tailp, ki_next;
   key_item_t *array;
   int narray, idx;
 
   if (count < key_table_threshold)
     return 0;  /* Nothing to do.  */
 
   /* Unlink from the global list so that other threads don't disturb
    * us.  If another thread adds or removes something only one will be
    * the winner.  Bad luck for the dropped cache items but after all
    * it is just a cache.  */
   list_head = key_table[hash];
   key_table[hash] = NULL;
 
   /* Put all items into an array for sorting.  */
   array = xtrycalloc (count, sizeof *array);
   if (!array)
     {
       /* That's bad; give up all items of the bucket.  */
       err = gpg_error_from_syserror ();
       log_info ("Note: malloc failed while purging from the cache: %s\n",
                 gpg_strerror (err));
       goto leave;
     }
   narray = 0;
   for (ki = list_head; ki; ki = ki_next)
     {
       ki_next = ki->next;
       array[narray++] = ki;
       ki->next = NULL;
     }
   log_assert (narray == count);
 
   /* Sort the array and put half of it onto a new list.  */
   qsort (array, narray, sizeof *array, compare_key_items);
   list_head = NULL;
   list_tailp = &list_head;
   for (idx=0; idx < narray/2; idx++)
     {
       *list_tailp = array[idx];
       list_tailp = &array[idx]->next;
     }
 
   /* Put the new list into the bucket.  */
   ki = key_table[hash];
   key_table[hash] = list_head;
   list_head = ki;
 
   /* Free the remaining items and the array.  */
   for (; idx < narray; idx++)
     {
       key_item_unref (array[idx]);
       key_table_dropped++;
     }
   xfree (array);
   err = gpg_error (GPG_ERR_TRUE);
 
  leave:
   /* Free any items added in the meantime by other threads.  This is
    * also used in case of a malloc problem (which won't update the
    * counters, though). */
   for ( ; list_head; list_head = ki_next)
     {
       ki_next = list_head->next;
       key_item_unref (list_head);
     }
   return err;
 }
 
 
 /* Thsi is the core of
  *   key_table_put,
  *   key_table_put_no_fpr,
  *   key_table_put_no_kid.
  */
 static void
 do_key_table_put (u32 kid_h, u32 kid_l,
                   const unsigned char *fpr, unsigned int fprlen,
                   const unsigned char *ubid, int subkey)
 {
   unsigned int hash;
   key_item_t ki;
   bloblist_t bl, bl_tail;
   unsigned int count;
   int do_find_again;
   int mark_not_found = !fpr;
 
   hash = key_table_hasher (kid_l);
  find_again:
   do_find_again = 0;
   ki = find_in_chain (hash, kid_h, kid_l, &count);
   if (ki)
     {
       if (mark_not_found)
         return; /* Can't put the mark because meanwhile a entry was
                  * added.  */
 
       for (bl = ki->blist; bl; bl = bl->next)
         if (bl->fprlen
             && bl->fprlen == fprlen
             && !memcmp (bl->fpr, fpr, fprlen))
           break;
       if (bl)
         return;  /* Already in the bloblist for the keyid  */
 
       /* Append to the list.  */
       if (!bloblist_attic)
         {
           if (alloc_more_bloblist_items ())
             return;  /* Out of core - ignore.  */
           goto find_again; /* Need to start over due to the malloc.  */
         }
       for (bl_tail = NULL, bl = ki->blist; bl; bl_tail = bl, bl = bl->next)
         ;
       bl = new_bloblist_item (fpr, fprlen, ubid, subkey);
       if (bl_tail)
         bl_tail->next = bl;
       else
         ki->blist = bl;
 
       return;
     }
 
   /* If the bucket is full remove a couple of items. */
   if (maybe_flush_some_key_buckets (hash, count))
     {
       /* During the fucntion call another thread might have changed
        * the bucket.  Thus we need to start over.  */
       do_find_again = 1;
     }
 
   if (!key_item_attic)
     {
       if (alloc_more_key_items ())
         return;  /* Out of core - ignore.  */
       do_find_again = 1;
     }
 
   if (!bloblist_attic)
     {
       if (alloc_more_bloblist_items ())
         return;  /* Out of core - ignore.  */
       do_find_again = 1;
     }
 
   if (do_find_again)
     goto find_again;
 
   /* We now know that there are items in the attics.  Put them into
    * the chain.  Note that we may not use any system call here. */
   ki = key_item_attic;
   key_item_attic = ki->next;
   ki->next = NULL;
 
   if (mark_not_found)
     ki->blist = NULL;
   else
     ki->blist = new_bloblist_item (fpr, fprlen, ubid, subkey);
 
   ki->kid_h = kid_h;
   ki->kid_l = kid_l;
   ki->usecount = 1;
   ki->refcount = 1;
 
   ki->next = key_table[hash];
   key_table[hash] = ki;
   key_table_added++;
 }
 
 
 /* Given the fingerprint (FPR,FPRLEN) put the UBID into the cache.
  * SUBKEY indicates that the fingerprint is from a subkey.  */
 static void
 key_table_put (const unsigned char *fpr, unsigned int fprlen,
                const unsigned char *ubid, int subkey)
 {
   u32 kid_h, kid_l;
 
   if (fprlen < 20 || fprlen > 32)
     return;  /* No support for v3 keys or unknown key versions.  */
 
   if (fprlen == 20)  /* v4 key */
     {
       kid_h = buf32_to_u32 (fpr+12);
       kid_l = buf32_to_u32 (fpr+16);
     }
   else  /* v5 or later key */
     {
       kid_h = buf32_to_u32 (fpr);
       kid_l = buf32_to_u32 (fpr+4);
     }
   do_key_table_put (kid_h, kid_l, fpr, fprlen, ubid, subkey);
 }
 
 
 /* Given the fingerprint (FPR,FPRLEN) put a flag into the cache that
  * this fingerprint was not found.  */
 static void
 key_table_put_no_fpr (const unsigned char *fpr, unsigned int fprlen)
 {
   u32 kid_h, kid_l;
 
   if (fprlen < 20 || fprlen > 32)
     return;  /* No support for v3 keys or unknown key versions.  */
 
   if (fprlen == 20)  /* v4 key */
     {
       kid_h = buf32_to_u32 (fpr+12);
       kid_l = buf32_to_u32 (fpr+16);
     }
   else  /* v5 or later key */
     {
       kid_h = buf32_to_u32 (fpr);
       kid_l = buf32_to_u32 (fpr+4);
     }
   /* Note that our not-found chaching is only based on the keyid. */
   do_key_table_put (kid_h, kid_l, NULL, 0, NULL, 0);
 }
 
 
 /* Given the keyid (KID_H, KID_L) put a flag into the cache that this
  * keyid was not found. */
 static void
 key_table_put_no_kid (u32 kid_h, u32 kid_l)
 {
   do_key_table_put (kid_h, kid_l, NULL, 0, NULL, 0);
 }
 
 
 /* Given the keyid or the fingerprint return the key item from the
  * cache.  The caller must release the result using key_item_unref.
  * NULL is returned if not found.  */
 static key_item_t
 key_table_get (u32 kid_h, u32 kid_l)
 {
   unsigned int hash;
   key_item_t ki;
 
   hash = key_table_hasher (kid_l);
   ki = find_in_chain (hash, kid_h, kid_l, NULL);
   if (ki)
     {
       ki->usecount++;
       ki->refcount++;
       return ki;  /* Found  */
     }
 
   return NULL;
 }
 
 
 /* Return a key item by searching for the keyid.  The caller must use
  * key_item_unref on it.  */
 static key_item_t
 query_by_kid (u32 kid_h, u32 kid_l)
 {
   return key_table_get (kid_h, kid_l);
 }
 
 
 /* Return a key item by searching for the fingerprint.  The caller
  * must use key_item_unref on it.  Note that the returned key item may
  * not actually carry the fingerprint; the caller needs to scan the
  * bloblist of the keyitem.  We can't do that here because the
  * reference counting is done on the keyitem s and thus this needs to
  * be returned. */
 static key_item_t
 query_by_fpr (const unsigned char *fpr, unsigned int fprlen)
 {
   u32 kid_h, kid_l;
 
   if (fprlen < 20 || fprlen > 32 )
     return NULL;  /* No support for v3 keys or unknown key versions.  */
 
   if (fprlen == 20)  /* v4 key */
     {
       kid_h = buf32_to_u32 (fpr+12);
       kid_l = buf32_to_u32 (fpr+16);
     }
   else  /* v5 or later key */
     {
       kid_h = buf32_to_u32 (fpr);
       kid_l = buf32_to_u32 (fpr+4);
     }
 
   return key_table_get (kid_h, kid_l);
 }
 
 
 
 
 
 /* Install a new resource and return a handle for that backend.  */
 gpg_error_t
 be_cache_add_resource (ctrl_t ctrl, backend_handle_t *r_hd)
 {
   gpg_error_t err;
   backend_handle_t hd;
 
   (void)ctrl;
 
   *r_hd = NULL;
   hd = xtrycalloc (1, sizeof *hd);
   if (!hd)
     return gpg_error_from_syserror ();
   hd->db_type = DB_TYPE_CACHE;
 
   hd->backend_id = be_new_backend_id ();
 
   err = blob_table_init ();
   if (err)
     goto leave;
 
   err = key_table_init ();
   if (err)
     goto leave;
 
   *r_hd = hd;
   hd = NULL;
 
  leave:
   xfree (hd);
   return err;
 }
 
 
 /* Release the backend handle HD and all its resources.  HD is not
  * valid after a call to this function.  */
 void
 be_cache_release_resource (ctrl_t ctrl, backend_handle_t hd)
 {
   (void)ctrl;
 
   if (!hd)
     return;
   hd->db_type = DB_TYPE_NONE;
 
   /* Fixme: Free the key_table.  */
 
   xfree (hd);
 }
 
 
 /* Search for the keys described by (DESC,NDESC) and return them to
  * the caller.  BACKEND_HD is the handle for this backend and REQUEST
  * is the current database request object.  On a cache hit either 0 or
  * GPG_ERR_NOT_FOUND is returned.  The former returns the item; the
  * latter indicates that the cache has known that the item won't be
  * found in any databases.  On a cache miss GPG_ERR_EOF is
  * returned.  */
 gpg_error_t
 be_cache_search (ctrl_t ctrl, backend_handle_t backend_hd, db_request_t request,
                  KEYDB_SEARCH_DESC *desc, unsigned int ndesc)
 {
   gpg_error_t err;
   db_request_part_t reqpart;
   unsigned int n;
   blob_t b;
   key_item_t ki;
   bloblist_t bl;
   int not_found = 0;
   int descidx = 0;
   int found_bykid = 0;
 
   log_assert (backend_hd && backend_hd->db_type == DB_TYPE_CACHE);
   log_assert (request);
 
   err = be_find_request_part (backend_hd, request, &reqpart);
   if (err)
     goto leave;
 
   if (!desc)
     {
       /* Reset operation.  */
       request->last_cached_valid = 0;
       request->last_cached_final = 0;
       reqpart->cache_seqno.fpr = 0;
       reqpart->cache_seqno.kid = 0;
       reqpart->cache_seqno.grip = 0;
+      reqpart->cache_seqno.ubid = 0;
       err = 0;
       goto leave;
     }
 
   for (ki = NULL, n=0; n < ndesc && !ki; n++)
     {
       descidx = n;
       switch (desc[n].mode)
         {
         case KEYDB_SEARCH_MODE_LONG_KID:
           ki = query_by_kid (desc[n].u.kid[0], desc[n].u.kid[1]);
           if (ki && ki->blist)
             {
               not_found = 0;
               /* Note that in a bloblist all keyids are the same.  */
               for (n=0, bl = ki->blist; bl; bl = bl->next)
                 if (n++ == reqpart->cache_seqno.kid)
                   break;
               if (!bl)
                 {
                   key_item_unref (ki);
                   ki = NULL;
                 }
               else
                 {
                   found_bykid = 1;
                   reqpart->cache_seqno.kid++;
                 }
             }
           else if (ki)
             not_found = 1;
           break;
 
         case KEYDB_SEARCH_MODE_FPR:
           ki = query_by_fpr (desc[n].u.fpr, desc[n].fprlen);
           if (ki && ki->blist)
             {
               not_found = 0;
               for (n=0, bl = ki->blist; bl; bl = bl->next)
                 if (bl->fprlen
                     && bl->fprlen == desc[n].fprlen
                     && !memcmp (bl->fpr, desc[n].u.fpr, desc[n].fprlen)
                     && n++ == reqpart->cache_seqno.fpr)
                   break;
               if (!bl)
                 {
                   key_item_unref (ki);
                   ki = NULL;
                 }
               else
                 reqpart->cache_seqno.fpr++;
             }
           else if (ki)
             not_found = 1;
           break;
 
         /* case KEYDB_SEARCH_MODE_KEYGRIP: */
         /*   ki = query_by_grip (desc[n].u.fpr, desc[n].fprlen); */
         /*   break; */
 
+        case KEYDB_SEARCH_MODE_UBID:
+          /* This is the quite special UBID mode: If this is
+           * encountered in the search list we will return just this
+           * one and obviously look only into the blob cache.  */
+          if (reqpart->cache_seqno.ubid)
+            err = gpg_error (GPG_ERR_NOT_FOUND);
+          else
+            {
+              b = blob_table_get (desc[n].u.ubid);
+              if (b)
+                {
+                  err = be_return_pubkey (ctrl, b->data, b->datalen,
+                                          b->pktype, desc[n].u.ubid);
+                  blob_unref (b);
+                  reqpart->cache_seqno.ubid++;
+                }
+              else
+                err = gpg_error (GPG_ERR_EOF);
+            }
+          goto leave;
+
         default:
           ki = NULL;
           break;
         }
     }
 
   if (not_found)
     {
       err = gpg_error (GPG_ERR_NOT_FOUND);
       key_item_unref (ki);
     }
   else if (ki)
     {
       if (bl && bl->ubid_valid)
         {
           memcpy (request->last_cached_ubid, bl->ubid, 20);
           request->last_cached_valid = 1;
           request->last_cached_fprlen = desc[descidx].fprlen;
           memcpy (request->last_cached_fpr,
                   desc[descidx].u.fpr, desc[descidx].fprlen);
           request->last_cached_kid_h = ki->kid_h;
           request->last_cached_kid_l = ki->kid_l;
           request->last_cached_valid = 1;
           if ((bl->final_kid && found_bykid)
               || (bl->final_fpr && !found_bykid))
             request->last_cached_final = 1;
           else
             request->last_cached_final = 0;
 
           b = blob_table_get (bl->ubid);
           if (b)
             {
               err = be_return_pubkey (ctrl, b->data, b->datalen,
                                       PUBKEY_TYPE_OPGP, bl->ubid);
               blob_unref (b);
             }
           else
             {
               /* FIXME - return a different code so that the caller
                * can lookup using the UBID.  */
               err = gpg_error (GPG_ERR_MISSING_VALUE);
             }
         }
       else if (bl)
         err = gpg_error (GPG_ERR_MISSING_VALUE);
       else
         err = gpg_error (GPG_ERR_NOT_FOUND);
       key_item_unref (ki);
     }
   else
     err = gpg_error (GPG_ERR_EOF);
 
  leave:
   return err;
 }
 
 
 /* Mark the last cached item as the final item.  This is called when
  * the actual database returned EOF in respond to a restart from the
  * last cached UBID.  */
 void
 be_cache_mark_final (ctrl_t ctrl, db_request_t request)
 {
   key_item_t ki;
   bloblist_t bl, blfound;
 
   (void)ctrl;
 
   log_assert (request);
 
   if (!request->last_cached_valid)
     return;
 
   if (!request->last_cached_fprlen) /* Was cached via keyid.  */
     {
       ki = query_by_kid (request->last_cached_kid_h,
                          request->last_cached_kid_l);
       if (ki && (bl = ki->blist))
         {
           for (blfound=NULL; bl; bl = bl->next)
             blfound = bl;
           if (blfound)
             blfound->final_kid = 1;
         }
       key_item_unref (ki);
     }
   else /* Was cached via fingerprint.  */
     {
       ki = query_by_fpr (request->last_cached_fpr,
                          request->last_cached_fprlen);
       if (ki && (bl = ki->blist))
         {
           for (blfound=NULL; bl; bl = bl->next)
             if (bl->fprlen
                 && bl->fprlen == request->last_cached_fprlen
                 && !memcmp (bl->fpr, request->last_cached_fpr,
                             request->last_cached_fprlen))
               blfound = bl;
           if (blfound)
             blfound->final_fpr = 1;
         }
       key_item_unref (ki);
     }
 
   request->last_cached_valid = 0;
 }
 
 
 /* Put the key (BLOB,BLOBLEN) of PUBKEY_TYPE into the cache.  */
 void
 be_cache_pubkey (ctrl_t ctrl, const unsigned char *ubid,
                  const void *blob, unsigned int bloblen,
                  enum pubkey_types pubkey_type)
 {
   gpg_error_t err;
 
   (void)ctrl;
 
   if (pubkey_type == PUBKEY_TYPE_OPGP)
     {
       struct _keybox_openpgp_info info;
       struct _keybox_openpgp_key_info *kinfo;
 
       err = _keybox_parse_openpgp (blob, bloblen, NULL, &info);
       if (err)
         {
           log_info ("cache: error parsing OpenPGP blob: %s\n",
                     gpg_strerror (err));
           return;
         }
 
-      blob_table_put (ubid, blob, bloblen);
+      blob_table_put (ubid, pubkey_type, blob, bloblen);
 
       kinfo = &info.primary;
       key_table_put (kinfo->fpr, kinfo->fprlen, ubid, 0);
       if (info.nsubkeys)
         for (kinfo = &info.subkeys; kinfo; kinfo = kinfo->next)
           key_table_put (kinfo->fpr, kinfo->fprlen, ubid, 1);
 
       _keybox_destroy_openpgp_info (&info);
     }
 
 }
 
 
 /* Put the a non-found mark for PUBKEY_TYPE into the cache.  The
  * indices are taken from the search descriptors (DESC,NDESC).  */
 void
 be_cache_not_found (ctrl_t ctrl, enum pubkey_types pubkey_type,
                     KEYDB_SEARCH_DESC *desc, unsigned int ndesc)
 {
   unsigned int n;
 
   (void)ctrl;
   (void)pubkey_type;
 
   for (n=0; n < ndesc; n++)
     {
       switch (desc->mode)
         {
         case KEYDB_SEARCH_MODE_LONG_KID:
           key_table_put_no_kid (desc[n].u.kid[0], desc[n].u.kid[1]);
           break;
 
         case KEYDB_SEARCH_MODE_FPR:
           key_table_put_no_fpr (desc[n].u.fpr, desc[n].fprlen);
           break;
 
         default:
           break;
         }
     }
 }
diff --git a/kbx/backend-kbx.c b/kbx/backend-kbx.c
index e58b74a3b..851f2dadf 100644
--- a/kbx/backend-kbx.c
+++ b/kbx/backend-kbx.c
@@ -1,326 +1,328 @@
 /* backend-kbx.c - Keybox format backend for keyboxd
  * Copyright (C) 2019 g10 Code GmbH
  *
  * This file is part of GnuPG.
  *
  * GnuPG 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 3 of the License, or
  * (at your option) any later version.
  *
  * GnuPG 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 this program; if not, see <https://www.gnu.org/licenses/>.
  * SPDX-License-Identifier: GPL-3.0-or-later
  */
 
 #include <config.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <stddef.h>
 #include <string.h>
 
 #include "keyboxd.h"
 #include "../common/i18n.h"
 #include "backend.h"
 #include "keybox.h"
 
 
 /* Our definition of the backend handle.  */
 struct backend_handle_s
 {
   enum database_types db_type; /* Always DB_TYPE_KBX.  */
   unsigned int backend_id;     /* Always the id of the backend.  */
 
   void *token;  /* Used to create a new KEYBOX_HANDLE.  */
   char filename[1];
 };
 
 
 /* Check that the file FILENAME is a valid keybox file which can be
  * used here.  Common return codes:
  *
  * 0              := Valid keybox file
  * GPG_ERR_ENOENT := No such file
  * GPG_ERR_NO_OBJ := File exists with size zero.
  * GPG_ERR_INV_OBJ:= File exists but is not a keybox file.
  */
 static gpg_error_t
 check_kbx_file_magic (const char *filename)
 {
   gpg_error_t err;
   u32 magic;
   unsigned char verbuf[4];
   estream_t fp;
 
   fp = es_fopen (filename, "rb");
   if (!fp)
     return gpg_error_from_syserror ();
 
   err = gpg_error (GPG_ERR_INV_OBJ);
   if (es_fread (&magic, 4, 1, fp) == 1 )
     {
       if (es_fread (&verbuf, 4, 1, fp) == 1
           && verbuf[0] == 1
           && es_fread (&magic, 4, 1, fp) == 1
           && !memcmp (&magic, "KBXf", 4))
         {
           err = 0;
         }
     }
   else /* Maybe empty: Let's create it. */
     err = gpg_error (GPG_ERR_NO_OBJ);
 
   es_fclose (fp);
   return err;
 }
 
 
 /* Create new keybox file.  This can also be used if the keybox
  * already exists but has a length of zero.  Do not use it in any
  * other cases.  */
 static gpg_error_t
 create_keybox (const char *filename)
 {
   gpg_error_t err;
   dotlock_t lockhd = NULL;
   estream_t fp;
 
   /* To avoid races with other temporary instances of keyboxd trying
    * to create or update the keybox, we do the next stuff in a locked
    * state. */
   lockhd = dotlock_create (filename, 0);
   if (!lockhd)
     {
       err = gpg_error_from_syserror ();
       /* A reason for this to fail is that the directory is not
        * writable. However, this whole locking stuff does not make
        * sense if this is the case. An empty non-writable directory
        * with no keybox is not really useful at all. */
       if (opt.verbose)
         log_info ("can't allocate lock for '%s': %s\n",
                   filename, gpg_strerror (err));
       return err;
     }
 
   if ( dotlock_take (lockhd, -1) )
     {
       err = gpg_error_from_syserror ();
       /* This is something bad.  Probably a stale lockfile.  */
       log_info ("can't lock '%s': %s\n", filename, gpg_strerror (err));
       goto leave;
     }
 
   /* Make sure that at least one record is in a new keybox file, so
    * that the detection magic will work the next time it is used.
    * We always set the OpenPGP blobs maybe availabale flag.   */
   fp = es_fopen (filename, "w+b,mode=-rw-------");
   if (!fp)
     {
       err = gpg_error_from_syserror ();
       log_error (_("error creating keybox '%s': %s\n"),
                  filename, gpg_strerror (err));
       goto leave;
     }
   err = _keybox_write_header_blob (NULL, fp, 1);
   es_fclose (fp);
   if (err)
     {
       log_error (_("error creating keybox '%s': %s\n"),
                  filename, gpg_strerror (err));
       goto leave;
     }
 
   if (!opt.quiet)
     log_info (_("keybox '%s' created\n"), filename);
   err = 0;
 
  leave:
   if (lockhd)
     {
       dotlock_release (lockhd);
       dotlock_destroy (lockhd);
     }
   return err;
 }
 
 
 
 /* Install a new resource and return a handle for that backend.  */
 gpg_error_t
 be_kbx_add_resource (ctrl_t ctrl, backend_handle_t *r_hd,
                      const char *filename, int readonly)
 {
   gpg_error_t err;
   backend_handle_t hd;
   void *token;
 
   (void)ctrl;
 
   *r_hd = NULL;
   hd = xtrycalloc (1, sizeof *hd + strlen (filename));
   if (!hd)
     return gpg_error_from_syserror ();
   hd->db_type = DB_TYPE_KBX;
   strcpy (hd->filename, filename);
 
   err = check_kbx_file_magic (filename);
   switch (gpg_err_code (err))
     {
     case 0:
       break;
     case GPG_ERR_ENOENT:
     case GPG_ERR_NO_OBJ:
       if (readonly)
         {
           err = gpg_error (GPG_ERR_ENOENT);
           goto leave;
         }
       err = create_keybox (filename);
       if (err)
         goto leave;
       break;
     default:
       goto leave;
     }
 
   err = keybox_register_file (filename, 0, &token);
   if (err)
     goto leave;
 
   hd->backend_id = be_new_backend_id ();
   hd->token = token;
 
   *r_hd = hd;
   hd = NULL;
 
  leave:
   xfree (hd);
   return 0;
 }
 
 
 /* Release the backend handle HD and all its resources.  HD is not
  * valid after a call to this function.  */
 void
 be_kbx_release_resource (ctrl_t ctrl, backend_handle_t hd)
 {
   (void)ctrl;
 
   if (!hd)
     return;
   hd->db_type = DB_TYPE_NONE;
 
   xfree (hd);
 }
 
 
 void
 be_kbx_release_kbx_hd (KEYBOX_HANDLE kbx_hd)
 {
   keybox_release (kbx_hd);
 }
 
 
 /* Helper for be_find_request_part to initialize a kbx request part.  */
 gpg_error_t
 be_kbx_init_request_part (backend_handle_t backend_hd, db_request_part_t part)
 {
   part->kbx_hd = keybox_new_openpgp (backend_hd->token, 0);
   if (!part->kbx_hd)
     return gpg_error_from_syserror ();
   return 0;
 }
 
 
 /* Search for the keys described by (DESC,NDESC) and return them to
  * the caller.  BACKEND_HD is the handle for this backend and REQUEST
  * is the current database request object.  */
 gpg_error_t
 be_kbx_search (ctrl_t ctrl, backend_handle_t backend_hd, db_request_t request,
                KEYDB_SEARCH_DESC *desc, unsigned int ndesc)
 {
   gpg_error_t err;
   db_request_part_t part;
   size_t descindex;
   unsigned long skipped_long_blobs;
 
   log_assert (backend_hd && backend_hd->db_type == DB_TYPE_KBX);
   log_assert (request);
 
   /* Find the specific request part or allocate it.  */
   err = be_find_request_part (backend_hd, request, &part);
   if (err)
     goto leave;
 
   if (!desc)
     err = keybox_search_reset (part->kbx_hd);
   else
     err = keybox_search (part->kbx_hd, desc, ndesc, KEYBOX_BLOBTYPE_PGP,
                          &descindex, &skipped_long_blobs);
   if (err == -1)
     err = gpg_error (GPG_ERR_EOF);
 
   if (desc && !err)
     {
       /* Successful search operation.  */
       void *buffer;
       size_t buflen;
       enum pubkey_types pubkey_type;
       unsigned char blobid[20];
 
       err = keybox_get_data (part->kbx_hd, &buffer, &buflen, &pubkey_type);
       if (err)
         goto leave;
       gcry_md_hash_buffer (GCRY_MD_SHA1, blobid, buffer, buflen);
       err = be_return_pubkey (ctrl, buffer, buflen, pubkey_type, blobid);
       if (!err)
         be_cache_pubkey (ctrl, blobid, buffer, buflen, pubkey_type);
       xfree (buffer);
     }
 
  leave:
   return err;
 }
 
 
 /* Seek in the keybox to the given UBID.  BACKEND_HD is the handle for
  * this backend and REQUEST is the current database request object.
  * This does a dummy read so that the next search operation starts
  * right after that UBID. */
 gpg_error_t
 be_kbx_seek (ctrl_t ctrl, backend_handle_t backend_hd,
                   db_request_t request, unsigned char *ubid)
 {
   gpg_error_t err;
   db_request_part_t part;
   size_t descindex;
   unsigned long skipped_long_blobs;
   KEYDB_SEARCH_DESC desc;
 
+  (void)ctrl;
+
   log_assert (backend_hd && backend_hd->db_type == DB_TYPE_KBX);
   log_assert (request);
 
   memset (&desc, 0, sizeof desc);
   desc.mode = KEYDB_SEARCH_MODE_UBID;
   memcpy (desc.u.ubid, ubid, 20);
 
   /* Find the specific request part or allocate it.  */
   err = be_find_request_part (backend_hd, request, &part);
   if (err)
     goto leave;
 
   err = keybox_search_reset (part->kbx_hd);
   if (!err)
     err = keybox_search (part->kbx_hd, &desc, 1, 0,
                          &descindex, &skipped_long_blobs);
   if (err == -1)
     err = gpg_error (GPG_ERR_EOF);
 
  leave:
   return err;
 }
diff --git a/kbx/backend.h b/kbx/backend.h
index 8b389d35c..675ec213d 100644
--- a/kbx/backend.h
+++ b/kbx/backend.h
@@ -1,139 +1,140 @@
 /* backend.h - Definitions for keyboxd backends
  * Copyright (C) 2019 g10 Code GmbH
  *
  * This file is part of GnuPG.
  *
  * GnuPG 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 3 of the License, or
  * (at your option) any later version.
  *
  * GnuPG 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 this program; if not, see <https://www.gnu.org/licenses/>.
  */
 
 #ifndef KBX_BACKEND_H
 #define KBX_BACKEND_H
 
 #include "keybox-search-desc.h"
 
 /* Forward declaration of the keybox handle type.  */
 struct keybox_handle;
 typedef struct keybox_handle *KEYBOX_HANDLE;
 
 
 /* The types of the backends.  */
 enum database_types
   {
    DB_TYPE_NONE,   /* No database at all (unitialized etc.).  */
    DB_TYPE_CACHE,  /* The cache backend (backend-cache.c).    */
    DB_TYPE_KBX     /* Keybox type database (backend-kbx.c).   */
   };
 
 
 /* Declaration of the backend handle.  Each backend uses its own
  * hidden handle structure with the only common thing being that the
  * first field is the database_type to help with debugging.  */
 struct backend_handle_s;
 typedef struct backend_handle_s *backend_handle_t;
 
 
 /* Object to store backend specific database information per database
  * handle.  */
 struct db_request_part_s
 {
   struct db_request_part_s *next;
 
   /* Id of the backend instance this object pertains to.  */
   unsigned int backend_id;
 
   /* The handle used for a KBX backend or NULL.  */
   KEYBOX_HANDLE kbx_hd;
 
   /* For the CACHE backend the indices into the bloblist for each
    * index type.  */
   struct {
     unsigned int fpr;
     unsigned int kid;
     unsigned int grip;
+    unsigned int ubid;
   } cache_seqno;
 };
 typedef struct db_request_part_s *db_request_part_t;
 
 
 /* A database request handle.  This keeps per session search
  * information as well as a list of per-backend infos.  */
 struct db_request_s
 {
   unsigned int any_search:1;  /* Any search has been done.  */
   unsigned int any_found:1;   /* Any object has been found.  */
   unsigned int last_cached_valid:1; /* see below */
   unsigned int last_cached_final:1; /* see below */
   unsigned int last_cached_fprlen:8;/* see below */
 
   db_request_part_t part;
 
   /* Counter to track the next to be searched database index.  */
   unsigned int next_dbidx;
 
   /* The last UBID found in the cache and the corresponding keyid and,
    * if found via fpr, the fingerprint.  For the LAST_CACHE_FPRLEN see
    * above.  The entry here is only valid if LAST_CACHE_VALID is set;
    * if LAST_CACHE_FINAL is also set, this indicates that no further
    * database searches are required.  */
   unsigned char last_cached_ubid[20];
   u32 last_cached_kid_h;
   u32 last_cached_kid_l;
   unsigned char last_cached_fpr[32];
 };
 
 
 
 /*-- backend-support.c --*/
 const char *strdbtype (enum database_types t);
 unsigned int be_new_backend_id (void);
 void be_generic_release_backend (ctrl_t ctrl, backend_handle_t hd);
 void be_release_request (db_request_t req);
 gpg_error_t be_find_request_part (backend_handle_t backend_hd,
                                   db_request_t request,
                                   db_request_part_t *r_part);
 gpg_error_t be_return_pubkey (ctrl_t ctrl, const void *buffer, size_t buflen,
                               enum pubkey_types pubkey_type,
                               const unsigned char *ubid);
 
 
 /*-- backend-cache.c --*/
 gpg_error_t be_cache_add_resource (ctrl_t ctrl, backend_handle_t *r_hd);
 void be_cache_release_resource (ctrl_t ctrl, backend_handle_t hd);
 gpg_error_t be_cache_search (ctrl_t ctrl, backend_handle_t backend_hd,
                              db_request_t request,
                              KEYDB_SEARCH_DESC *desc, unsigned int ndesc);
 void be_cache_mark_final (ctrl_t ctrl, db_request_t request);
 void be_cache_pubkey (ctrl_t ctrl, const unsigned char *ubid,
                       const void *blob, unsigned int bloblen,
                       enum pubkey_types pubkey_type);
 void be_cache_not_found (ctrl_t ctrl, enum pubkey_types pubkey_type,
                          KEYDB_SEARCH_DESC *desc, unsigned int ndesc);
 
 
 /*-- backend-kbx.c --*/
 gpg_error_t be_kbx_add_resource (ctrl_t ctrl, backend_handle_t *r_hd,
                                  const char *filename, int readonly);
 void be_kbx_release_resource (ctrl_t ctrl, backend_handle_t hd);
 
 void be_kbx_release_kbx_hd (KEYBOX_HANDLE kbx_hd);
 gpg_error_t be_kbx_init_request_part (backend_handle_t backend_hd,
                                       db_request_part_t part);
 gpg_error_t be_kbx_search (ctrl_t ctrl, backend_handle_t hd,
                            db_request_t request,
                            KEYDB_SEARCH_DESC *desc, unsigned int ndesc);
 gpg_error_t be_kbx_seek (ctrl_t ctrl, backend_handle_t backend_hd,
                          db_request_t request, unsigned char *ubid);
 
 
 #endif /*KBX_BACKEND_H*/