No OneTemporary
Actions

Size

391 KB

Subscribers

None

View Options

This file is larger than 256 KB, so syntax highlighting was skipped.

	diff --git a/common/userids.c b/common/userids.c
	index eb714a9af..5e2704362 100644
	--- a/common/userids.c
	+++ b/common/userids.c
	@@ -1,489 +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)
	+ if (hex2bin (s+1, desc->u.ubid, UBID_LEN) < 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/common/util.h b/common/util.h
	index 6c878083a..fc869800a 100644
	--- a/common/util.h
	+++ b/common/util.h
	@@ -1,394 +1,398 @@
	/* util.h - Utility functions for GnuPG
	* Copyright (C) 2001, 2002, 2003, 2004, 2009 Free Software Foundation, Inc.
	*
	* This file is part of GnuPG.
	*
	* GnuPG is free software; you can redistribute and/or modify this
	* part of GnuPG 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.
	*
	* 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 copies of the GNU General Public License
	* and the GNU Lesser General Public License along with this program;
	* if not, see <https://www.gnu.org/licenses/>.
	*/

	#ifndef GNUPG_COMMON_UTIL_H
	#define GNUPG_COMMON_UTIL_H

	#include <gcrypt.h> /* We need this for the memory function protos. */
	#include <errno.h> /* We need errno. */
	#include <gpg-error.h> /* We need gpg_error_t and estream. */

	/* These error codes are used but not defined in the required
	* libgpg-error version. Define them here.
	* Example: (#if GPG_ERROR_VERSION_NUMBER < 0x011500 // 1.21)
	*/
	#if GPG_ERROR_VERSION_NUMBER < 0x012400 /* 1.36 */
	#define GPG_ERR_NO_AUTH 314
	#define GPG_ERR_BAD_AUTH 315
	#endif /GPG_ERROR_VERSION_NUMBER/
	#if GPG_ERROR_VERSION_NUMBER < 0x012500 /* 1.37 */
	#define GPG_ERR_NO_KEYBOXD 316
	#define GPG_ERR_KEYBOXD 317
	#endif /GPG_ERROR_VERSION_NUMBER/

	/* Hash function used with libksba. */
	#define HASH_FNC ((void ()(void , const void*,size_t))gcry_md_write)

	/* The length of the keygrip. This is a SHA-1 hash of the key
	* parameters as generated by gcry_pk_get_keygrip. */
	#define KEYGRIP_LEN 20

	+/* The length of the unique blob identifier as used by the keyboxd.
	+ * This is the possible truncated fingerprint of the primary key. */
	+#define UBID_LEN 20
	+

	/* Get all the stuff from jnlib. */
	#include "../common/logging.h"
	#include "../common/argparse.h"
	#include "../common/stringhelp.h"
	#include "../common/mischelp.h"
	#include "../common/strlist.h"
	#include "../common/dotlock.h"
	#include "../common/utf8conv.h"
	#include "../common/dynload.h"
	#include "../common/fwddecl.h"
	#include "../common/utilproto.h"

	#include "gettime.h"

	/* Redefine asprintf by our estream version which uses our own memory
	allocator.. */
	#define asprintf gpgrt_asprintf
	#define vasprintf gpgrt_vasprintf

	/* Due to a bug in mingw32's snprintf related to the 'l' modifier and
	for increased portability we use our snprintf on all systems. */
	#undef snprintf
	#define snprintf gpgrt_snprintf


	/* Replacements for macros not available with libgpg-error < 1.20. */

	/* We need this type even if we are not using libreadline and or we
	did not include libreadline in the current file. */
	#ifndef GNUPG_LIBREADLINE_H_INCLUDED
	typedef char *rl_completion_func_t (const char , int, int);
	#endif /!GNUPG_LIBREADLINE_H_INCLUDED/


	/* Handy malloc macros - please use only them. */
	#define xtrymalloc(a) gcry_malloc ((a))
	#define xtrymalloc_secure(a) gcry_malloc_secure ((a))
	#define xtrycalloc(a,b) gcry_calloc ((a),(b))
	#define xtrycalloc_secure(a,b) gcry_calloc_secure ((a),(b))
	#define xtryrealloc(a,b) gcry_realloc ((a),(b))
	#define xtrystrdup(a) gcry_strdup ((a))
	#define xfree(a) gcry_free ((a))
	#define xfree_fnc gcry_free

	#define xmalloc(a) gcry_xmalloc ((a))
	#define xmalloc_secure(a) gcry_xmalloc_secure ((a))
	#define xcalloc(a,b) gcry_xcalloc ((a),(b))
	#define xcalloc_secure(a,b) gcry_xcalloc_secure ((a),(b))
	#define xrealloc(a,b) gcry_xrealloc ((a),(b))
	#define xstrdup(a) gcry_xstrdup ((a))

	/* For compatibility with gpg 1.4 we also define these: */
	#define xmalloc_clear(a) gcry_xcalloc (1, (a))
	#define xmalloc_secure_clear(a) gcry_xcalloc_secure (1, (a))

	/* The default error source of the application. This is different
	from GPG_ERR_SOURCE_DEFAULT in that it does not depend on the
	source file and thus is usable in code shared by applications.
	Defined by init.c. */
	extern gpg_err_source_t default_errsource;

	/* Convenience function to return a gpg-error code for memory
	allocation failures. This function makes sure that an error will
	be returned even if accidentally ERRNO is not set. */
	static inline gpg_error_t
	out_of_core (void)
	{
	return gpg_error_from_syserror ();
	}


	/-- yesno.c --/
	int answer_is_yes (const char *s);
	int answer_is_yes_no_default (const char *s, int def_answer);
	int answer_is_yes_no_quit (const char *s);
	int answer_is_okay_cancel (const char *s, int def_answer);

	/-- xreadline.c --/
	ssize_t read_line (FILE *fp,
	char *addr_of_buffer, size_t length_of_buffer,
	size_t *max_length);


	/-- b64enc.c and b64dec.c --/
	struct b64state
	{
	unsigned int flags;
	int idx;
	int quad_count;
	FILE *fp;
	estream_t stream;
	char *title;
	unsigned char radbuf[4];
	u32 crc;
	int stop_seen:1;
	int invalid_encoding:1;
	gpg_error_t lasterr;
	};

	gpg_error_t b64enc_start (struct b64state state, FILE fp, const char *title);
	gpg_error_t b64enc_start_es (struct b64state *state, estream_t fp,
	const char *title);
	gpg_error_t b64enc_write (struct b64state *state,
	const void *buffer, size_t nbytes);
	gpg_error_t b64enc_finish (struct b64state *state);

	gpg_error_t b64dec_start (struct b64state state, const char title);
	gpg_error_t b64dec_proc (struct b64state state, void buffer, size_t length,
	size_t *r_nbytes);
	gpg_error_t b64dec_finish (struct b64state *state);

	/-- sexputil.c /
	char canon_sexp_to_string (const unsigned char canon, size_t canonlen);
	void log_printcanon (const char *text,
	const unsigned char *sexp, size_t sexplen);
	void log_printsexp (const char *text, gcry_sexp_t sexp);

	gpg_error_t make_canon_sexp (gcry_sexp_t sexp,
	unsigned char *r_buffer, size_t r_buflen);
	gpg_error_t make_canon_sexp_pad (gcry_sexp_t sexp, int secure,
	unsigned char *r_buffer, size_t r_buflen);
	gpg_error_t keygrip_from_canon_sexp (const unsigned char *key, size_t keylen,
	unsigned char *grip);
	int cmp_simple_canon_sexp (const unsigned char a, const unsigned char b);
	unsigned char make_simple_sexp_from_hexstr (const char line,
	size_t *nscanned);
	int hash_algo_from_sigval (const unsigned char *sigval);
	unsigned char make_canon_sexp_from_rsa_pk (const void m, size_t mlen,
	const void *e, size_t elen,
	size_t *r_len);
	gpg_error_t get_rsa_pk_from_canon_sexp (const unsigned char *keydata,
	size_t keydatalen,
	unsigned char const **r_n,
	size_t *r_nlen,
	unsigned char const **r_e,
	size_t *r_elen);

	int get_pk_algo_from_key (gcry_sexp_t key);
	int get_pk_algo_from_canon_sexp (const unsigned char *keydata,
	size_t keydatalen);
	char pubkey_algo_string (gcry_sexp_t s_pkey, enum gcry_pk_algos r_algoid);

	/-- convert.c --/
	int hex2bin (const char string, void buffer, size_t length);
	int hexcolon2bin (const char string, void buffer, size_t length);
	char bin2hex (const void buffer, size_t length, char *stringbuf);
	char bin2hexcolon (const void buffer, size_t length, char *stringbuf);
	const char hex2str (const char hexstring,
	char buffer, size_t bufsize, size_t buflen);
	char hex2str_alloc (const char hexstring, size_t *r_count);
	unsigned int hex2fixedbuf (const char hexstr, void buffer, size_t bufsize);

	/-- percent.c --/
	char percent_plus_escape (const char string);
	char percent_data_escape (int plus, const char prefix,
	const void *data, size_t datalen);
	char percent_plus_unescape (const char string, int nulrepl);
	char percent_unescape (const char string, int nulrepl);

	size_t percent_plus_unescape_inplace (char *string, int nulrepl);
	size_t percent_unescape_inplace (char *string, int nulrepl);

	/-- openpgp-oid.c --/
	gpg_error_t openpgp_oid_from_str (const char string, gcry_mpi_t r_mpi);
	char openpgp_oidbuf_to_str (const unsigned char buf, size_t len);
	char *openpgp_oid_to_str (gcry_mpi_t a);
	int openpgp_oidbuf_is_ed25519 (const void *buf, size_t len);
	int openpgp_oid_is_ed25519 (gcry_mpi_t a);
	int openpgp_oidbuf_is_cv25519 (const void *buf, size_t len);
	int openpgp_oid_is_cv25519 (gcry_mpi_t a);
	const char openpgp_curve_to_oid (const char name, unsigned int *r_nbits);
	const char openpgp_oid_to_curve (const char oid, int canon);
	const char openpgp_enum_curves (int idxp);
	const char openpgp_is_curve_supported (const char name,
	int r_algo, unsigned int r_nbits);


	/-- homedir.c --/
	const char *standard_homedir (void);
	const char *default_homedir (void);
	void gnupg_set_homedir (const char *newdir);
	const char *gnupg_homedir (void);
	int gnupg_default_homedir_p (void);
	const char *gnupg_daemon_rootdir (void);
	const char *gnupg_socketdir (void);
	const char *gnupg_sysconfdir (void);
	const char *gnupg_bindir (void);
	const char *gnupg_libexecdir (void);
	const char *gnupg_libdir (void);
	const char *gnupg_datadir (void);
	const char *gnupg_localedir (void);
	const char *gnupg_cachedir (void);
	const char *gpg_agent_socket_name (void);
	const char *dirmngr_socket_name (void);

	char _gnupg_socketdir_internal (int skip_checks, unsigned r_info);

	/* All module names. We also include gpg and gpgsm for the sake for
	gpgconf. */
	#define GNUPG_MODULE_NAME_AGENT 1
	#define GNUPG_MODULE_NAME_PINENTRY 2
	#define GNUPG_MODULE_NAME_SCDAEMON 3
	#define GNUPG_MODULE_NAME_DIRMNGR 4
	#define GNUPG_MODULE_NAME_PROTECT_TOOL 5
	#define GNUPG_MODULE_NAME_CHECK_PATTERN 6
	#define GNUPG_MODULE_NAME_GPGSM 7
	#define GNUPG_MODULE_NAME_GPG 8
	#define GNUPG_MODULE_NAME_CONNECT_AGENT 9
	#define GNUPG_MODULE_NAME_GPGCONF 10
	#define GNUPG_MODULE_NAME_DIRMNGR_LDAP 11
	#define GNUPG_MODULE_NAME_GPGV 12
	#define GNUPG_MODULE_NAME_KEYBOXD 13
	const char *gnupg_module_name (int which);
	void gnupg_module_name_flush_some (void);
	void gnupg_set_builddir (const char *newdir);


	/* A list of constants to identify protocols. This is used by tools
	* which need to distinguish between the different protocols
	* implemented by GnuPG. May be used as bit flags. */
	#define GNUPG_PROTOCOL_OPENPGP 1 /* The one and only (gpg). */
	#define GNUPG_PROTOCOL_CMS 2 /* The core of S/MIME (gpgsm) */
	#define GNUPG_PROTOCOL_SSH_AGENT 4 /* Out ssh-agent implementation */


	/-- gpgrlhelp.c --/
	void gnupg_rl_initialize (void);

	/-- helpfile.c --/
	char gnupg_get_help_string (const char key, int only_current_locale);

	/-- localename.c --/
	const char *gnupg_messages_locale_name (void);

	/-- miscellaneous.c --/

	/* This function is called at startup to tell libgcrypt to use our own
	logging subsystem. */
	void setup_libgcrypt_logging (void);

	/* Print an out of core message and die. */
	void xoutofcore (void);

	/* Same as estream_asprintf but die on memory failure. */
	char xasprintf (const char fmt, ...) GPGRT_ATTR_PRINTF(1,2);
	/* This is now an alias to estream_asprintf. */
	char xtryasprintf (const char fmt, ...) GPGRT_ATTR_PRINTF(1,2);

	/* Replacement for gcry_cipher_algo_name. */
	const char *gnupg_cipher_algo_name (int algo);

	void obsolete_option (const char *configname, unsigned int configlineno,
	const char *name);

	const char print_fname_stdout (const char s);
	const char print_fname_stdin (const char s);
	void print_utf8_buffer3 (estream_t fp, const void *p, size_t n,
	const char *delim);
	void print_utf8_buffer2 (estream_t fp, const void *p, size_t n, int delim);
	void print_utf8_buffer (estream_t fp, const void *p, size_t n);
	void print_utf8_string (estream_t stream, const char *p);
	void print_hexstring (FILE fp, const void buffer, size_t length,
	int reserved);
	char try_make_printable_string (const void p, size_t n, int delim);
	char make_printable_string (const void p, size_t n, int delim);
	char decode_c_string (const char src);

	int is_file_compressed (const char s, int ret_rc);

	int match_multistr (const char multistr,const char match);

	int gnupg_compare_version (const char a, const char b);

	struct debug_flags_s
	{
	unsigned int flag;
	const char *name;
	};
	int parse_debug_flag (const char string, unsigned int debugvar,
	const struct debug_flags_s *flags);


	/-- Simple replacement functions. /

	/* We use the gnupg_ttyname macro to be safe not to run into conflicts
	which an extisting but broken ttyname. */
	#if !defined(HAVE_TTYNAME) \|\| defined(HAVE_BROKEN_TTYNAME)
	# define gnupg_ttyname(n) _gnupg_ttyname ((n))
	/* Systems without ttyname (W32) will merely return NULL. */
	static inline char *
	_gnupg_ttyname (int fd)
	{
	(void)fd;
	return NULL;
	}
	#else /HAVE_TTYNAME/
	# define gnupg_ttyname(n) ttyname ((n))
	#endif /HAVE_TTYNAME /

	#ifdef HAVE_W32CE_SYSTEM
	#define getpid() GetCurrentProcessId ()
	char _gnupg_getenv (const char name); /* See sysutils.c */
	#define getenv(a) _gnupg_getenv ((a))
	char _gnupg_setenv (const char name); /* See sysutils.c */
	#define setenv(a,b,c) _gnupg_setenv ((a),(b),(c))
	int _gnupg_isatty (int fd);
	#define gnupg_isatty(a) _gnupg_isatty ((a))
	#else
	#define gnupg_isatty(a) isatty ((a))
	#endif



	/-- Macros to replace ctype ones to avoid locale problems. --/
	#define spacep(p) ((p) == ' ' \|\| (p) == '\t')
	#define digitp(p) ((p) >= '0' && (p) <= '9')
	#define alphap(p) (((p) >= 'A' && (p) <= 'Z') \
	\|\| ((p) >= 'a' && (p) <= 'z'))
	#define alnump(p) (alphap (p) \|\| digitp (p))
	#define hexdigitp(a) (digitp (a) \
	\|\| ((a) >= 'A' && (a) <= 'F') \
	\|\| ((a) >= 'a' && (a) <= 'f'))
	/* Note this isn't identical to a C locale isspace() without \f and
	\v, but works for the purposes used here. */
	#define ascii_isspace(a) ((a)==' ' \|\| (a)=='\n' \|\| (a)=='\r' \|\| (a)=='\t')

	/* The atoi macros assume that the buffer has only valid digits. */
	#define atoi_1(p) (*(p) - '0' )
	#define atoi_2(p) ((atoi_1(p) * 10) + atoi_1((p)+1))
	#define atoi_4(p) ((atoi_2(p) * 100) + atoi_2((p)+2))
	#define xtoi_1(p) ((p) <= '9'? ((p)- '0'): \
	(p) <= 'F'? ((p)-'A'+10):(*(p)-'a'+10))
	#define xtoi_2(p) ((xtoi_1(p) * 16) + xtoi_1((p)+1))
	#define xtoi_4(p) ((xtoi_2(p) * 256) + xtoi_2((p)+2))

	#endif /GNUPG_COMMON_UTIL_H/
	diff --git a/doc/DETAILS b/doc/DETAILS
	index 6ce340e8c..bd00006e9 100644
	--- a/doc/DETAILS
	+++ b/doc/DETAILS
	@@ -1,1601 +1,1600 @@
	# 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, by a 2 digit hexnumber and
	optionally followed by the letter 's' for the "sensitive"
	flag. This field is 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. The length is only
	exact for binary formats; other formats ('t', 'u') may do post
	processing like line ending conversion so that the actual number
	of bytes written may be differ.

	*** 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. <location> and <error code> may not
	contain spaces. The <location> may be used to indicate a class of
	warnings. 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".
	*** NOTE <location> <error code> [<text>]
	This is a generic info status message the same syntax as for
	WARNING messages is used.
	*** 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 (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 (^).
	+ and <ubid> the Unique Blob ID (UBID) which is the fingerprint of
	+ the primary key truncated to 20 octets and formatted in hex. 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 9625587ac..99dfac58f 100644
	--- a/g10/call-keyboxd.c
	+++ b/g10/call-keyboxd.c
	@@ -1,1145 +1,1145 @@
	/* 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).
	* In keyboxd mode the keyboxd decides where to store it.
	*
	* 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. Note
	* that keydb_new sets this flag as well. */
	hd->kbl->need_search_reset = 1;
	err = 0;

	leave:
	return err;
	}



	/* Status callback for SEARCH and NEXT operaions. */
	static gpg_error_t
	search_status_cb (void opaque, const char line)
	{
	KEYDB_HANDLE hd = opaque;
	gpg_error_t err = 0;
	const char *s;

	if ((s = has_leading_keyword (line, "PUBKEY_INFO")))
	{
	if (atoi (s) != PUBKEY_TYPE_OPGP)
	err = gpg_error (GPG_ERR_WRONG_BLOB_TYPE);
	else
	{
	hd->last_ubid_valid = 0;
	while (*s && !spacep (s))
	s++;
	if (hex2fixedbuf (s, hd->last_ubid, sizeof hd->last_ubid))
	hd->last_ubid_valid = 1;
	else
	err = gpg_error (GPG_ERR_INV_VALUE);
	}
	}

	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);
	+ unsigned char hexubid[UBID_LEN * 2 + 1];
	+ bin2hex (desc[0].u.grip, UBID_LEN, 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:
	hd->last_ubid_valid = 0;
	if (hd->kbl->datastream.fp)
	{
	/* log_debug ("Sending command '%s'\n", line); */
	err = assuan_transact (hd->kbl->ctx, line,
	NULL, NULL,
	NULL, NULL,
	search_status_cb, hd);
	if (err)
	{
	/* log_debug ("Finished command with error: %s\n", gpg_strerror (err)); */
	/* Fixme: On unexpected errors we need a way to cancel the
	* data stream. Probably it will be best to close and
	* 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,
	search_status_cb, hd);
	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);
	}

	/* if (hd->last_ubid_valid) */
	/* log_printhex (hd->last_ubid, 20, "found UBID:"); */

	leave:
	if (DBG_CLOCK)
	log_clock ("%s leave (%sfound)", __func__, err? "not ":"");
	return err;
	}
	diff --git a/g10/keydb-private.h b/g10/keydb-private.h
	index 47a09ca93..fdc905edf 100644
	--- a/g10/keydb-private.h
	+++ b/g10/keydb-private.h
	@@ -1,177 +1,177 @@
	/* keydb-private.h - Common definitions for keydb.c and call-keyboxd.c
	* 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
	*/

	#ifndef G10_KEYDB_PRIVATE_H
	#define G10_KEYDB_PRIVATE_H

	#include <assuan.h>
	#include "../common/membuf.h"


	/* Ugly forward declarations. */
	struct keyring_handle;
	typedef struct keyring_handle *KEYRING_HANDLE;
	struct keybox_handle;
	typedef struct keybox_handle *KEYBOX_HANDLE;


	/* This is for keydb.c and only used in non-keyboxd mode. */
	#define MAX_KEYDB_RESOURCES 40

	/* This is for keydb.c and only used in non-keyboxd mode. */
	typedef enum
	{
	KEYDB_RESOURCE_TYPE_NONE = 0,
	KEYDB_RESOURCE_TYPE_KEYRING,
	KEYDB_RESOURCE_TYPE_KEYBOX
	} KeydbResourceType;

	/* This is for keydb.c and only used in non-keyboxd mode. */
	struct resource_item
	{
	KeydbResourceType type;
	union {
	KEYRING_HANDLE kr;
	KEYBOX_HANDLE kb;
	} u;
	void *token;
	};


	/* This is a simple cache used to return the last result of a
	* successful fingerprint search. This works only for keybox
	* resources because (due to lack of a copy_keyblock function) we need
	* to store an image of the keyblock which is fortunately instantly
	* available for keyboxes. Only used in non-keyboxd mode. */
	enum keyblock_cache_states {
	KEYBLOCK_CACHE_EMPTY,
	KEYBLOCK_CACHE_PREPARED,
	KEYBLOCK_CACHE_FILLED
	};

	struct keyblock_cache {
	enum keyblock_cache_states state;
	byte fpr[MAX_FINGERPRINT_LEN];
	byte fprlen;
	iobuf_t iobuf; /* Image of the keyblock. */
	int pk_no;
	int uid_no;
	/* Offset of the record in the keybox. */
	int resource;
	off_t offset;
	};


	/* The definition of the KEYDB_HANDLE as used internally by keydb.c and
	* the newer call-keyboxd. */
	struct keydb_handle_s
	{
	/* Flag set if this handles pertains to call-keyboxd.c. */
	int use_keyboxd;

	/* BEGIN USE_KEYBOXD */
	/* (These fields are only valid if USE_KEYBOXD is set.) */

	/* A shallow pointer with the CTRL used to create this handle. */
	ctrl_t ctrl;

	/* Connection info which also keeps the local state. (This points
	* into the CTRL->keybox_local list.) */
	keyboxd_local_t kbl;

	/* Various flags. */
	unsigned int last_ubid_valid:1;

	/* The UBID of the last returned keyblock. */
	- unsigned char last_ubid[20];
	+ unsigned char last_ubid[UBID_LEN];

	/* END USE_KEYBOXD */

	/* BEGIN !USE_KEYBOXD */
	/* (The remaining fields are only valid if USE_KEYBOXD is cleared.) */

	/* When we locked all of the resources in ACTIVE (using keyring_lock
	* / keybox_lock, as appropriate). */
	int locked;

	/* If this flag is set a lock will only be released by
	* keydb_release. */
	int keep_lock;

	/* The index into ACTIVE of the resources in which the last search
	result was found. Initially -1. */
	int found;

	/* Initially -1 (invalid). This is used to save a search result and
	later restore it as the selected result. */
	int saved_found;

	/* The number of skipped long blobs since the last search
	(keydb_search_reset). */
	unsigned long skipped_long_blobs;

	/* If set, this disables the use of the keyblock cache. */
	int no_caching;

	/* Whether the next search will be from the beginning of the
	database (and thus consider all records). */
	int is_reset;

	/* The "file position." In our case, this is index of the current
	resource in ACTIVE. */
	int current;

	/* The number of resources in ACTIVE. */
	int used;

	/* Cache of the last found and parsed key block (only used for
	keyboxes, not keyrings). */
	struct keyblock_cache keyblock_cache;

	/* Copy of ALL_RESOURCES when keydb_new is called. */
	struct resource_item active[MAX_KEYDB_RESOURCES];

	/* END !USE_KEYBOXD */
	};


	/-- keydb.c --/

	/* These are the functions call-keyboxd diverts to if the keyboxd is
	* not used. */

	gpg_error_t internal_keydb_init (KEYDB_HANDLE hd);
	void internal_keydb_deinit (KEYDB_HANDLE hd);
	gpg_error_t internal_keydb_lock (KEYDB_HANDLE hd);

	gpg_error_t internal_keydb_get_keyblock (KEYDB_HANDLE hd, KBNODE *ret_kb);
	gpg_error_t internal_keydb_update_keyblock (ctrl_t ctrl,
	KEYDB_HANDLE hd, kbnode_t kb);
	gpg_error_t internal_keydb_insert_keyblock (KEYDB_HANDLE hd, kbnode_t kb);
	gpg_error_t internal_keydb_delete_keyblock (KEYDB_HANDLE hd);
	gpg_error_t internal_keydb_search_reset (KEYDB_HANDLE hd);
	gpg_error_t internal_keydb_search (KEYDB_HANDLE hd, KEYDB_SEARCH_DESC *desc,
	size_t ndesc, size_t *descindex);





	#endif /G10_KEYDB_PRIVATE_H/
	diff --git a/g10/keydb.c b/g10/keydb.c
	index 57d51e7b7..bf411371e 100644
	--- a/g10/keydb.c
	+++ b/g10/keydb.c
	@@ -1,1954 +1,1954 @@
	/* 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/
	+#if MAX_FINGERPRINT_LEN < UBID_LEN \|\| MAX_FINGERPRINT_LEN < KEYGRIP_LEN
	+#error MAX_FINGERPRINT_LEN is shorter than KEYGRIP or 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:
	- bin2hex (desc[0].u.grip, 20, fpr);
	+ bin2hex (desc[0].u.grip, KEYGRIP_LEN, fpr);
	return xasprintf ("KEYGRIP: %s", fpr);
	case KEYDB_SEARCH_MODE_UBID:
	- bin2hex (desc[0].u.ubid, 20, fpr);
	+ bin2hex (desc[0].u.ubid, UBID_LEN, 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
	{
	KEYBOX_HANDLE kbxhd;

	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;

	/* Do a compress run if needed and no other user is
	* currently using the keybox. */
	kbxhd = keybox_new_openpgp (token, 0);
	if (kbxhd)
	{
	if (!keybox_lock (kbxhd, 1, 0))
	{
	keybox_compress (kbxhd);
	keybox_lock (kbxhd, 0, 0);
	}

	keybox_release (kbxhd);
	}

	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;
	}


	/* 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)
	{
	keydb_stats.build_keyblocks++;
	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)
	{
	keydb_stats.build_keyblocks++;
	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 10a6f6bd9..45e5c7158 100644
	--- a/kbx/backend-cache.c
	+++ b/kbx/backend-cache.c
	@@ -1,1190 +1,1200 @@
	/* 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];
	+ unsigned char ubid[UBID_LEN];
	} *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. */
	+ unsigned char ubid[UBID_LEN]; /* 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))
	+ if (!memcmp (b->ubid, ubid, UBID_LEN))
	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, 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);
	+ memcpy (b->ubid, ubid, UBID_LEN);
	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);
	+ memcpy (bl->ubid, ubid, UBID_LEN);
	else
	- memset (bl->ubid, 0, 20);
	+ memset (bl->ubid, 0, UBID_LEN);
	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);
	}





	+/* Make sure the tables are initialized. */
	+gpg_error_t
	+be_cache_initialize (void)
	+{
	+ gpg_error_t err;
	+
	+ err = blob_table_init ();
	+ if (!err)
	+ err = key_table_init ();
	+ return err;
	+}
	+
	+
	/* 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 ();
	+ /* Just in case make sure we are initialized. */
	+ err = be_cache_initialize ();
	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);
	+ memcpy (request->last_cached_ubid, bl->ubid, UBID_LEN);
	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, 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 d8dafe0e5..ff4f56773 100644
	--- a/kbx/backend-kbx.c
	+++ b/kbx/backend-kbx.c
	@@ -1,439 +1,427 @@
	/* 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 err;
	}


	/* 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];
	+ unsigned char ubid[UBID_LEN];

	- err = keybox_get_data (part->kbx_hd, &buffer, &buflen, &pubkey_type);
	+ err = keybox_get_data (part->kbx_hd, &buffer, &buflen,
	+ &pubkey_type, ubid);
	if (err)
	goto leave;
	- gcry_md_hash_buffer (GCRY_MD_SHA1, blobid, buffer, buflen);
	- err = be_return_pubkey (ctrl, buffer, buflen, pubkey_type, blobid);
	+ err = be_return_pubkey (ctrl, buffer, buflen, pubkey_type, ubid);
	if (!err)
	- be_cache_pubkey (ctrl, blobid, buffer, buflen, pubkey_type);
	+ be_cache_pubkey (ctrl, ubid, buffer, buflen, pubkey_type);
	xfree (buffer);
	}

	leave:
	return err;
	}


	/* Seek in the keybox to the given UBID (if UBID is not NULL) or to
	* the primary fingerprint specified by (FPR,FPRLEN). 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, const unsigned char *ubid,
	- const unsigned char *fpr, unsigned int fprlen)
	+ db_request_t request, const 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);
	- if (ubid)
	- {
	- desc.mode = KEYDB_SEARCH_MODE_FPR;
	- memcpy (desc.u.ubid, ubid, 20);
	- }
	- else
	- {
	- if (fprlen > sizeof desc.u.fpr)
	- return gpg_error (GPG_ERR_TOO_LARGE);
	- desc.mode = KEYDB_SEARCH_MODE_FPR;
	- memcpy (desc.u.fpr, fpr, fprlen);
	- desc.fprlen = fprlen;
	- }
	+ desc.mode = KEYDB_SEARCH_MODE_UBID;
	+ memcpy (desc.u.ubid, ubid, UBID_LEN);

	/* 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;
	}


	/* Insert (BLOB,BLOBLEN) into the keybox. BACKEND_HD is the handle
	* for this backend and REQUEST is the current database request
	* object. */
	gpg_error_t
	be_kbx_insert (ctrl_t ctrl, backend_handle_t backend_hd,
	db_request_t request, enum pubkey_types pktype,
	const void *blob, size_t bloblen)
	{
	gpg_error_t err;
	db_request_part_t part;
	ksba_cert_t cert = NULL;

	(void)ctrl;

	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 (pktype == PUBKEY_TYPE_OPGP)
	err = keybox_insert_keyblock (part->kbx_hd, blob, bloblen);
	else if (pktype == PUBKEY_TYPE_X509)
	{
	unsigned char sha1[20];

	err = ksba_cert_new (&cert);
	if (err)
	goto leave;
	err = ksba_cert_init_from_mem (cert, blob, bloblen);
	if (err)
	goto leave;
	gcry_md_hash_buffer (GCRY_MD_SHA1, sha1, blob, bloblen);

	err = keybox_insert_cert (part->kbx_hd, cert, sha1);
	}
	else
	err = gpg_error (GPG_ERR_WRONG_BLOB_TYPE);

	leave:
	ksba_cert_release (cert);
	return err;
	}


	/* Update (BLOB,BLOBLEN) in the keybox. BACKEND_HD is the handle for
	* this backend and REQUEST is the current database request object. */
	gpg_error_t
	be_kbx_update (ctrl_t ctrl, backend_handle_t backend_hd,
	db_request_t request, enum pubkey_types pktype,
	const void *blob, size_t bloblen)
	{
	gpg_error_t err;
	db_request_part_t part;
	ksba_cert_t cert = NULL;

	(void)ctrl;

	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;

	/* FIXME: We make use of the fact that we know that the caller
	* already did a keybox search. This needs to be made more
	* explicit. */
	if (pktype == PUBKEY_TYPE_OPGP)
	{
	err = keybox_update_keyblock (part->kbx_hd, blob, bloblen);
	}
	else if (pktype == PUBKEY_TYPE_X509)
	{
	unsigned char sha1[20];

	err = ksba_cert_new (&cert);
	if (err)
	goto leave;
	err = ksba_cert_init_from_mem (cert, blob, bloblen);
	if (err)
	goto leave;
	gcry_md_hash_buffer (GCRY_MD_SHA1, sha1, blob, bloblen);

	err = keybox_update_cert (part->kbx_hd, cert, sha1);
	}
	else
	err = gpg_error (GPG_ERR_WRONG_BLOB_TYPE);

	leave:
	ksba_cert_release (cert);
	return err;
	}
	diff --git a/kbx/backend-support.c b/kbx/backend-support.c
	index f1a97996f..f1e80b0c3 100644
	--- a/kbx/backend-support.c
	+++ b/kbx/backend-support.c
	@@ -1,276 +1,270 @@
	/* backend-support.c - Supporting functions for the backend.
	* 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+
	*/

	#include <config.h>
	#include <stdio.h>
	#include <stdlib.h>
	#include <stddef.h>
	#include <string.h>

	#include "keyboxd.h"
	#include "../common/i18n.h"
	#include "../common/asshelp.h"
	#include "../common/tlv.h"
	#include "backend.h"
	#include "keybox-defs.h"


	/* Common definition part of all backend handle. All definitions of
	* this structure must start with these fields. */
	struct backend_handle_s
	{
	enum database_types db_type;
	unsigned int backend_id;
	};



	/* Return a string with the name of the database type T. */
	const char *
	strdbtype (enum database_types t)
	{
	switch (t)
	{
	case DB_TYPE_NONE: return "none";
	case DB_TYPE_CACHE:return "cache";
	case DB_TYPE_KBX: return "keybox";
	}
	return "?";
	}


	/* Return a new backend ID. Backend IDs are used to identify backends
	* without using the actual object. The number of backend resources
	* is limited because they are specified in the config file. Thus an
	* overflow check is not required. */
	unsigned int
	be_new_backend_id (void)
	{
	static unsigned int last;

	return ++last;
	}


	/* Release the backend described by HD. This is a generic function
	* which dispatches to the the actual backend. */
	void
	be_generic_release_backend (ctrl_t ctrl, backend_handle_t hd)
	{
	if (!hd)
	return;
	switch (hd->db_type)
	{
	case DB_TYPE_NONE:
	xfree (hd);
	break;
	case DB_TYPE_CACHE:
	be_cache_release_resource (ctrl, hd);
	break;
	case DB_TYPE_KBX:
	be_kbx_release_resource (ctrl, hd);
	break;
	default:
	log_error ("%s: faulty backend handle of type %d given\n",
	__func__, hd->db_type);
	}
	}


	/* Release the request object REQ. */
	void
	be_release_request (db_request_t req)
	{
	db_request_part_t part, partn;

	if (!req)
	return;

	for (part = req->part; part; part = partn)
	{
	partn = part->next;
	be_kbx_release_kbx_hd (part->kbx_hd);
	xfree (part);
	}
	}


	/* Given the backend handle BACKEND_HD and the REQUEST find or
	* allocate a request part for that backend and store it at R_PART.
	* On error R_PART is set to NULL and an error returned. */
	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 err;
	db_request_part_t part;

	for (part = request->part; part; part = part->next)
	if (part->backend_id == backend_hd->backend_id)
	break;
	if (!part)
	{
	part = xtrycalloc (1, sizeof *part);
	if (!part)
	return gpg_error_from_syserror ();
	part->backend_id = backend_hd->backend_id;
	if (backend_hd->db_type == DB_TYPE_KBX)
	{
	err = be_kbx_init_request_part (backend_hd, part);
	if (err)
	{
	xfree (part);
	return err;
	}
	}
	part->next = request->part;
	request->part = part;
	}
	*r_part = part;
	return 0;
	}


	/* Return the public key (BUFFER,BUFLEN) which has the type
	* PUBKEY_TYPE to the caller. */
	gpg_error_t
	be_return_pubkey (ctrl_t ctrl, const void *buffer, size_t buflen,
	enum pubkey_types pubkey_type, const unsigned char *ubid)
	{
	gpg_error_t err;
	- char hexubid[41];
	+ char hexubid[2*UBID_LEN+1];

	- bin2hex (ubid, 20, hexubid);
	+ bin2hex (ubid, UBID_LEN, hexubid);
	err = status_printf (ctrl, "PUBKEY_INFO", "%d %s", pubkey_type, hexubid);
	if (err)
	goto leave;

	if (ctrl->no_data_return)
	err = 0;
	else
	err = kbxd_write_data_line(ctrl, buffer, buflen);

	leave:
	return err;
	}



	/* Return true if (BLOB/BLOBLEN) seems to be an X509 certificate. */
	static int
	is_x509_blob (const unsigned char *blob, size_t bloblen)
	{
	const unsigned char *p;
	size_t n, objlen, hdrlen;
	int class, tag, cons, ndef;

	/* An X.509 certificate can be identified by this DER encoding:
	*
	* 30 82 05 B8 30 82 04 A0 A0 03 02 01 02 02 07 15 46 A0 BF 30 07 39
	* ----------- +++++++++++ ----- ++++++++ --------------------------
	* SEQUENCE SEQUENCE [0] INTEGER INTEGER
	* (tbs) (version) (s/n)
	*
	*/

	p = blob;
	n = bloblen;
	if (parse_ber_header (&p, &n, &class, &tag, &cons, &ndef, &objlen, &hdrlen))
	return 0; /* Not a proper BER object. */
	if (!(class == CLASS_UNIVERSAL && tag == TAG_SEQUENCE && cons))
	return 0; /* Does not start with a sequence. */

	if (parse_ber_header (&p, &n, &class, &tag, &cons, &ndef, &objlen, &hdrlen))
	return 0; /* Not a proper BER object. */
	if (!(class == CLASS_UNIVERSAL && tag == TAG_SEQUENCE && cons))
	return 0; /* No TBS sequence. */
	if (n < 7 \|\| objlen < 7)
	return 0; /* Too short: [0], version and min. s/n required. */

	if (parse_ber_header (&p, &n, &class, &tag, &cons, &ndef, &objlen, &hdrlen))
	return 0; /* Not a proper BER object. */
	if (!(class == CLASS_CONTEXT && tag == 0 && cons))
	return 0; /* No context tag. */

	if (parse_ber_header (&p, &n, &class, &tag, &cons, &ndef, &objlen, &hdrlen))
	return 0; /* Not a proper BER object. */

	if (!(class == CLASS_UNIVERSAL && tag == TAG_INTEGER
	&& !cons && objlen == 1 && n && (p == 1 \|\| p == 2)))
	return 0; /* Unknown X.509 version. */
	p++; /* Skip version number. */
	n--;

	if (parse_ber_header (&p, &n, &class, &tag, &cons, &ndef, &objlen, &hdrlen))
	return 0; /* Not a proper BER object. */
	if (!(class == CLASS_UNIVERSAL && tag == TAG_INTEGER && !cons))
	return 0; /* No s/n. */

	return 1; /* Looks like an X.509 certificate. */
	}


	/* Return the public key type and the (primary) fingerprint for
	- * (BLOB,BLOBLEN). R_FPR must point to a buffer of at least 32 bytes,
	- * it received the fi gerprint on success with the length of that
	- * fingerprint stored at R_FPRLEN. R_PKTYPE receives the public key
	- * type. */
	+ * (BLOB,BLOBLEN). r_UBID must point to a buffer of at least UBID_LEN
	+ * bytes, on success it receives the UBID (primary fingerprint
	+ * truncated 20 octets). R_PKTYPE receives the public key type. */
	gpg_error_t
	-be_fingerprint_from_blob (const void *blob, size_t bloblen,
	- enum pubkey_types *r_pktype,
	- char r_fpr, unsigned int r_fprlen)
	+be_ubid_from_blob (const void *blob, size_t bloblen,
	+ enum pubkey_types r_pktype, char r_ubid)
	{
	gpg_error_t err;

	if (is_x509_blob (blob, bloblen))
	{
	/* Although libksba has a dedicated function to compute the
	* fingerprint we compute it here directly because we know that
	* we have the entire certificate here (we checked the start of
	* the blob and assume that the length is also okay). */
	*r_pktype = PUBKEY_TYPE_X509;
	- gcry_md_hash_buffer (GCRY_MD_SHA1, r_fpr, blob, bloblen);
	- *r_fprlen = 20;
	-
	+ gcry_md_hash_buffer (GCRY_MD_SHA1, r_ubid, blob, bloblen);
	err = 0;
	}
	else
	{
	struct _keybox_openpgp_info info;

	err = _keybox_parse_openpgp (blob, bloblen, NULL, &info);
	if (err)
	{
	log_info ("error parsing OpenPGP blob: %s\n", gpg_strerror (err));
	err = gpg_error (GPG_ERR_WRONG_BLOB_TYPE);
	}
	else
	{
	*r_pktype = PUBKEY_TYPE_OPGP;
	- log_assert (info.primary.fprlen <= 32);
	- memcpy (r_fpr, info.primary.fpr, info.primary.fprlen);
	- *r_fprlen = info.primary.fprlen;
	-
	+ log_assert (info.primary.fprlen >= 20);
	+ memcpy (r_ubid, info.primary.fpr, UBID_LEN);
	_keybox_destroy_openpgp_info (&info);
	}
	}

	return err;
	}
	diff --git a/kbx/backend.h b/kbx/backend.h
	index e97855246..c372d9071 100644
	--- a/kbx/backend.h
	+++ b/kbx/backend.h
	@@ -1,150 +1,149 @@
	/* 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
	+ * if found via fpr, the fingerprint. For the LAST_CACHED_FPRLEN see
	+ * above. The entry here is only valid if LAST_CACHED_VALID is set;
	+ * if LAST_CACHED_FINAL is also set, this indicates that no further
	* database searches are required. */
	- unsigned char last_cached_ubid[20];
	+ unsigned char last_cached_ubid[UBID_LEN];
	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);
	-gpg_error_t be_fingerprint_from_blob (const void *blob, size_t bloblen,
	- enum pubkey_types *r_pktype,
	- char r_fpr, unsigned int r_fprlen);
	+gpg_error_t be_ubid_from_blob (const void *blob, size_t bloblen,
	+ enum pubkey_types r_pktype, char r_ubid);


	/-- backend-cache.c --/
	+gpg_error_t be_cache_initialize (void);
	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, const unsigned char *ubid,
	- const unsigned char *fpr, unsigned int fprlen);
	+ db_request_t request, const unsigned char *ubid);
	gpg_error_t be_kbx_insert (ctrl_t ctrl, backend_handle_t backend_hd,
	db_request_t request, enum pubkey_types pktype,
	const void *blob, size_t bloblen);
	gpg_error_t be_kbx_update (ctrl_t ctrl, backend_handle_t backend_hd,
	db_request_t request, enum pubkey_types pktype,
	const void *blob, size_t bloblen);


	#endif /KBX_BACKEND_H/
	diff --git a/kbx/frontend.c b/kbx/frontend.c
	index 5bf18809e..de9373c8f 100644
	--- a/kbx/frontend.c
	+++ b/kbx/frontend.c
	@@ -1,466 +1,471 @@
	/* frontend.c - Database fronend code 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+
	*/

	#include <config.h>
	#include <stdio.h>
	#include <stdlib.h>
	#include <stddef.h>
	#include <string.h>

	#include "keyboxd.h"
	#include <assuan.h>
	#include "../common/i18n.h"
	#include "../common/userids.h"
	#include "backend.h"
	#include "frontend.h"


	/* An object to describe a single database. */
	struct db_desc_s
	{
	enum database_types db_type;
	backend_handle_t backend_handle;
	};
	typedef struct db_desc_s *db_desc_t;


	/* The table of databases and the size of that table. */
	static db_desc_t databases;
	static unsigned int no_of_databases;




	/* Take a lock for reading the databases. */
	static void
	take_read_lock (ctrl_t ctrl)
	{
	/* FIXME */
	(void)ctrl;
	}


	/* Take a lock for reading and writing the databases. */
	static void
	take_read_write_lock (ctrl_t ctrl)
	{
	/* FIXME */
	(void)ctrl;
	}


	/* Release a lock. It is valid to call this even if no lock has been
	* taken in which case this is a nop. */
	static void
	release_lock (ctrl_t ctrl)
	{
	/* FIXME */
	(void)ctrl;
	}


	/* Add a new resource to the database. Depending on the FILENAME
	* suffix we decide which one to use. This function must be called at
	* daemon startup because it employs no locking. If FILENAME has no
	* directory separator, the file is expected or created below
	* "$GNUPGHOME/public-keys-v1.d/". In READONLY mode the file must
	* exists; otherwise it is created. */
	gpg_error_t
	kbxd_add_resource (ctrl_t ctrl, const char *filename_arg, int readonly)
	{
	gpg_error_t err;
	char *filename;
	enum database_types db_type = 0;
	backend_handle_t handle = NULL;
	unsigned int n, dbidx;

	/* Do tilde expansion etc. */
	if (!strcmp (filename_arg, "[cache]"))
	{
	filename = xstrdup (filename_arg);
	db_type = DB_TYPE_CACHE;
	}
	else if (strchr (filename_arg, DIRSEP_C)
	#ifdef HAVE_W32_SYSTEM
	\|\| strchr (filename_arg, '/') /* Windows also accepts a slash. */
	#endif
	)
	filename = make_filename (filename_arg, NULL);
	else
	filename = make_filename (gnupg_homedir (), GNUPG_PUBLIC_KEYS_DIR,
	filename_arg, NULL);

	/* If this is the first call to the function and the request is not
	* for the cache backend, add the cache backend so that it will
	* always be the first to be queried. */
	if (!no_of_databases && !db_type)
	{
	- err = kbxd_add_resource (ctrl, "[cache]", 0);
	+ err = be_cache_initialize ();
	+ /* err = kbxd_add_resource (ctrl, "[cache]", 0); */
	if (err)
	goto leave;
	}

	n = strlen (filename);
	if (db_type)
	; /* We already know it. */
	else if (n > 4 && !strcmp (filename + n - 4, ".kbx"))
	db_type = DB_TYPE_KBX;
	else
	{
	log_error (_("can't use file '%s': %s\n"), filename, _("unknown suffix"));
	err = gpg_error (GPG_ERR_NOT_SUPPORTED);
	goto leave;
	}

	err = gpg_error (GPG_ERR_BUG);
	switch (db_type)
	{
	case DB_TYPE_NONE: /* NOTREACHED */
	break;

	case DB_TYPE_CACHE:
	err = be_cache_add_resource (ctrl, &handle);
	break;

	case DB_TYPE_KBX:
	err = be_kbx_add_resource (ctrl, &handle, filename, readonly);
	break;
	}
	if (err)
	goto leave;

	/* All good, create an entry in the table. */
	for (dbidx = 0; dbidx < no_of_databases; dbidx++)
	if (!databases[dbidx].db_type)
	break;
	if (dbidx == no_of_databases)
	{
	/* No table yet or table is full. */
	if (!databases)
	{
	/* Create first set of databases. Note that the initial
	* type for all entries is DB_TYPE_NONE. */
	dbidx = 4;
	databases = xtrycalloc (dbidx, sizeof *databases);
	if (!databases)
	{
	err = gpg_error_from_syserror ();
	goto leave;
	}
	no_of_databases = dbidx;
	dbidx = 0; /* Put into first slot. */
	}
	else
	{
	db_desc_t newdb;

	dbidx = no_of_databases + (no_of_databases == 4? 12 : 16);
	newdb = xtrycalloc (dbidx, sizeof *databases);
	if (!databases)
	{
	err = gpg_error_from_syserror ();
	goto leave;
	}
	for (n=0; n < no_of_databases; n++)
	newdb[n] = databases[n];
	xfree (databases);
	databases = newdb;
	n = no_of_databases;
	no_of_databases = dbidx;
	dbidx = n; /* Put into first new slot. */
	}
	}

	databases[dbidx].db_type = db_type;
	databases[dbidx].backend_handle = handle;
	handle = NULL;

	leave:
	if (err)
	{
	log_error ("error adding resource '%s': %s\n",
	filename, gpg_strerror (err));
	be_generic_release_backend (ctrl, handle);
	}
	xfree (filename);
	return err;
	}


	/* Release all per session objects. */
	void
	kbxd_release_session_info (ctrl_t ctrl)
	{
	if (!ctrl)
	return;
	be_release_request (ctrl->opgp_req);
	ctrl->opgp_req = NULL;
	be_release_request (ctrl->x509_req);
	ctrl->x509_req = NULL;
	}



	/* Search for the keys described by (DESC,NDESC) and return them to
	* the caller. If RESET is set, the search state is first reset. */
	gpg_error_t
	kbxd_search (ctrl_t ctrl, KEYDB_SEARCH_DESC *desc, unsigned int ndesc,
	int reset)
	{
	gpg_error_t err;
	int i;
	unsigned int dbidx;
	db_desc_t db;
	db_request_t request;
	int start_at_ubid = 0;

	if (DBG_CLOCK)
	log_clock ("%s: enter", __func__);

	if (DBG_LOOKUP)
	{
	log_debug ("%s: %u 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); */
	}
	}

	take_read_lock (ctrl);

	/* Allocate a handle object if none exists for this context. */
	if (!ctrl->opgp_req)
	{
	ctrl->opgp_req = xtrycalloc (1, sizeof *ctrl->opgp_req);
	if (!ctrl->opgp_req)
	{
	err = gpg_error_from_syserror ();
	goto leave;
	}
	}
	request = ctrl->opgp_req;

	/* If requested do a reset. Using the reset flag is faster than
	* letting the caller do a separate call for an intial reset. */
	if (!desc \|\| reset)
	{
	for (dbidx=0; dbidx < no_of_databases; dbidx++)
	{
	db = databases + dbidx;
	if (!db->db_type)
	continue; /* Empty slot. */

	switch (db->db_type)
	{
	case DB_TYPE_NONE: /* NOTREACHED */
	break;

	case DB_TYPE_CACHE:
	err = 0; /* Nothing to do. */
	break;

	case DB_TYPE_KBX:
	err = be_kbx_search (ctrl, db->backend_handle, request, NULL, 0);
	break;
	}
	if (err)
	{
	log_error ("error during the %ssearch reset: %s\n",
	reset? "initial ":"", gpg_strerror (err));
	goto leave;
	}
	}
	request->any_search = 0;
	request->any_found = 0;
	request->next_dbidx = 0;
	if (!desc) /* Reset only mode */
	{
	err = 0;
	goto leave;
	}
	}


	/* Move to the next non-empty slot. */
	next_db:
	for (dbidx=request->next_dbidx; (dbidx < no_of_databases
	&& !databases[dbidx].db_type); dbidx++)
	;
	request->next_dbidx = dbidx;
	if (!(dbidx < no_of_databases))
	{
	/* All databases have been searched. Put the non-found mark
	* into the cache for all descriptors.
	* FIXME: We need to see which pubkey type we need to insert. */
	be_cache_not_found (ctrl, PUBKEY_TYPE_UNKNOWN, desc, ndesc);
	err = gpg_error (GPG_ERR_NOT_FOUND);
	goto leave;
	}
	db = databases + dbidx;

	/* Divert to the backend for the actual search. */
	switch (db->db_type)
	{
	case DB_TYPE_NONE:
	/* NOTREACHED */
	err = gpg_error (GPG_ERR_INTERNAL);
	break;

	case DB_TYPE_CACHE:
	err = be_cache_search (ctrl, db->backend_handle, request,
	desc, ndesc);
	/* Expected error codes from the cache lookup are:
	* 0 - found and returned via the cache
	* GPG_ERR_NOT_FOUND - marked in the cache as not available
	* GPG_ERR_EOF - cache miss. */
	break;

	case DB_TYPE_KBX:
	if (start_at_ubid)
	{
	/* We need to set the startpoint for the search. */
	err = be_kbx_seek (ctrl, db->backend_handle, request,
	- request->last_cached_ubid, NULL, 0);
	+ request->last_cached_ubid);
	if (err)
	{
	log_debug ("%s: seeking %s to an UBID failed: %s\n",
	__func__, strdbtype (db->db_type), gpg_strerror (err));
	break;
	}
	}
	err = be_kbx_search (ctrl, db->backend_handle, request,
	desc, ndesc);
	if (start_at_ubid && gpg_err_code (err) == GPG_ERR_EOF)
	be_cache_mark_final (ctrl, request);
	break;
	}

	if (DBG_LOOKUP)
	log_debug ("%s: searched %s (db %u of %u) => %s\n",
	__func__, strdbtype (db->db_type), dbidx, no_of_databases,
	gpg_strerror (err));
	request->any_search = 1;
	start_at_ubid = 0;
	if (!err)
	{
	request->any_found = 1;
	}
	else if (gpg_err_code (err) == GPG_ERR_EOF)
	{
	if (db->db_type == DB_TYPE_CACHE && request->last_cached_valid)
	{
	if (request->last_cached_final)
	goto leave;
	start_at_ubid = 1;
	}
	request->next_dbidx++;
	goto next_db;
	}


	leave:
	release_lock (ctrl);
	if (DBG_CLOCK)
	log_clock ("%s: leave (%s)", __func__, err? "not found" : "found");
	return err;
	}



	-/* Store; that is insert or update the key (BLOB,BLOBLEN). If
	- * ONLY_UPDATE is set the key must exist. */
	+/* Store; that is insert or update the key (BLOB,BLOBLEN). MODE
	+ * controls whether only updates or only inserts are allowed. */
	gpg_error_t
	-kbxd_store (ctrl_t ctrl, const void *blob, size_t bloblen, int only_update)
	+kbxd_store (ctrl_t ctrl, const void *blob, size_t bloblen,
	+ enum kbxd_store_modes mode)
	{
	gpg_error_t err;
	db_request_t request;
	unsigned int dbidx;
	db_desc_t db;
	- char fpr[32];
	- unsigned int fprlen;
	+ char ubid[UBID_LEN];
	enum pubkey_types pktype;
	int insert = 0;

	if (DBG_CLOCK)
	log_clock ("%s: enter", __func__);

	take_read_write_lock (ctrl);

	/* Allocate a handle object if none exists for this context. */
	if (!ctrl->opgp_req)
	{
	ctrl->opgp_req = xtrycalloc (1, sizeof *ctrl->opgp_req);
	if (!ctrl->opgp_req)
	{
	err = gpg_error_from_syserror ();
	goto leave;
	}
	}
	request = ctrl->opgp_req;

	/* Check whether to insert or update. */
	- err = be_fingerprint_from_blob (blob, bloblen, &pktype, fpr, &fprlen);
	+ err = be_ubid_from_blob (blob, bloblen, &pktype, ubid);
	if (err)
	goto leave;

	/* FIXME: We force the use of the KBX backend. */
	for (dbidx=0; dbidx < no_of_databases; dbidx++)
	if (databases[dbidx].db_type == DB_TYPE_KBX)
	break;
	if (!(dbidx < no_of_databases))
	{
	err = gpg_error (GPG_ERR_NOT_INITIALIZED);
	goto leave;
	}
	db = databases + dbidx;

	- err = be_kbx_seek (ctrl, db->backend_handle, request, NULL, fpr, fprlen);
	+ err = be_kbx_seek (ctrl, db->backend_handle, request, ubid);
	if (!err)
	; /* Found - need to update. */
	else if (gpg_err_code (err) == GPG_ERR_EOF)
	insert = 1; /* Not found - need to insert. */
	else
	{
	log_debug ("%s: searching fingerprint failed: %s\n",
	__func__, gpg_strerror (err));
	goto leave;
	}

	if (insert)
	{
	- err = be_kbx_insert (ctrl, db->backend_handle, request,
	- pktype, blob, bloblen);
	+ if (mode == KBXD_STORE_UPDATE)
	+ err = gpg_error (GPG_ERR_CONFLICT);
	+ else
	+ err = be_kbx_insert (ctrl, db->backend_handle, request,
	+ pktype, blob, bloblen);
	}
	- else if (only_update)
	- err = gpg_error (GPG_ERR_DUP_KEY);
	else /* Update. */
	{
	- err = be_kbx_update (ctrl, db->backend_handle, request,
	- pktype, blob, bloblen);
	+ if (mode == KBXD_STORE_INSERT)
	+ err = gpg_error (GPG_ERR_CONFLICT);
	+ else
	+ err = be_kbx_update (ctrl, db->backend_handle, request,
	+ pktype, blob, bloblen);
	}

	leave:
	release_lock (ctrl);
	if (DBG_CLOCK)
	log_clock ("%s: leave", __func__);
	return err;
	}
	diff --git a/kbx/frontend.h b/kbx/frontend.h
	index 7c86514d0..45a8dbdbd 100644
	--- a/kbx/frontend.h
	+++ b/kbx/frontend.h
	@@ -1,38 +1,46 @@
	/* frontend.h - Definitions for the keyboxd frontend
	* 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_FRONTEND_H
	#define KBX_FRONTEND_H

	#include "keybox-search-desc.h"


	+enum kbxd_store_modes
	+ {
	+ KBXD_STORE_AUTO = 0, /* Update or insert. */
	+ KBXD_STORE_INSERT, /* Allow only inserts. */
	+ KBXD_STORE_UPDATE /* Allow only updates. */
	+ };
	+
	+
	gpg_error_t kbxd_add_resource (ctrl_t ctrl,
	const char *filename_arg, int readonly);

	void kbxd_release_session_info (ctrl_t ctrl);

	gpg_error_t kbxd_search (ctrl_t ctrl,
	KEYDB_SEARCH_DESC *desc, unsigned int ndesc,
	int reset);
	gpg_error_t kbxd_store (ctrl_t ctrl, const void *blob, size_t bloblen,
	- int only_update);
	+ enum kbxd_store_modes mode);


	#endif /KBX_FRONTEND_H/
	diff --git a/kbx/kbxserver.c b/kbx/kbxserver.c
	index 0da937f39..511362004 100644
	--- a/kbx/kbxserver.c
	+++ b/kbx/kbxserver.c
	@@ -1,825 +1,834 @@
	/* kbxserver.c - Handle Assuan commands send to the 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+
	*/

	#include <config.h>
	#include <stdio.h>
	#include <stdlib.h>
	#include <stddef.h>
	#include <string.h>
	#include <assert.h>
	#include <sys/types.h>
	#include <sys/stat.h>
	#include <unistd.h>
	#include <errno.h>

	#include "keyboxd.h"
	#include <assuan.h>
	#include "../common/i18n.h"
	#include "../common/server-help.h"
	#include "../common/userids.h"
	#include "../common/asshelp.h"
	#include "../common/host2net.h"
	#include "frontend.h"



	#define PARM_ERROR(t) assuan_set_error (ctx, \
	gpg_error (GPG_ERR_ASS_PARAMETER), (t))
	#define set_error(e,t) (ctx ? assuan_set_error (ctx, gpg_error (e), (t)) \
	/**/: gpg_error (e))



	/* Control structure per connection. */
	struct server_local_s
	{
	/* Data used to associate an Assuan context with local server data */
	assuan_context_t assuan_ctx;

	/* The session id (a counter). */
	unsigned int session_id;

	/* If this flag is set to true this process will be terminated after
	* the end of this session. */
	int stopme;

	/* If the first both flags are set the assuan logging of data lines
	* is suppressed. The count variable is used to show the number of
	* non-logged bytes. */
	size_t inhibit_data_logging_count;
	unsigned int inhibit_data_logging : 1;
	unsigned int inhibit_data_logging_now : 1;

	/* This flag is set if the last search command was called with --more. */
	unsigned int search_expecting_more : 1;

	/* This flag is set if the last search command was successful. */
	unsigned int search_any_found : 1;

	/* The first is the current search description as parsed by the
	* cmd_search. If more than one pattern is required, cmd_search
	* also allocates and sets multi_search_desc and
	* multi_search_desc_len. If a search description has ever been
	* allocated the allocated size is stored at
	* multi_search_desc_size. */
	KEYBOX_SEARCH_DESC search_desc;
	KEYBOX_SEARCH_DESC *multi_search_desc;
	unsigned int multi_search_desc_size;
	unsigned int multi_search_desc_len;

	/* If not NULL write output to this stream instead of using D lines. */
	estream_t outstream;
	};




	/* Return the assuan contxt from the local server info in CTRL. */
	static assuan_context_t
	get_assuan_ctx_from_ctrl (ctrl_t ctrl)
	{
	if (!ctrl \|\| !ctrl->server_local)
	return NULL;
	return ctrl->server_local->assuan_ctx;
	}


	/* If OUTPUT has been used prepare the output FD for use. This needs
	* to be called by all functions which will in any way use
	* kbxd_write_data_line later. Whether the output goes to the output
	* stream is decided by this function. */
	static gpg_error_t
	prepare_outstream (ctrl_t ctrl)
	{
	int fd;

	log_assert (ctrl && ctrl->server_local);

	if (ctrl->server_local->outstream)
	return 0; /* Already enabled. */

	fd = translate_sys2libc_fd
	(assuan_get_output_fd (get_assuan_ctx_from_ctrl (ctrl)), 1);
	if (fd == -1)
	return 0; /* No Output command active. */

	ctrl->server_local->outstream = es_fdopen_nc (fd, "w");
	if (!ctrl->server_local->outstream)
	return gpg_err_code_from_syserror ();
	return 0;
	}


	/* The usual writen function; here with diagnostic output. */
	static gpg_error_t
	kbxd_writen (estream_t fp, const void *buffer, size_t length)
	{
	gpg_error_t err;
	size_t nwritten;

	if (es_write (fp, buffer, length, &nwritten))
	{
	err = gpg_error_from_syserror ();
	log_error ("error writing OUTPUT: %s\n", gpg_strerror (err));
	}
	else if (length != nwritten)
	{
	err = gpg_error (GPG_ERR_EIO);
	log_error ("error writing OUTPUT: %s\n", "short write");
	}
	else
	err = 0;

	return err;
	}


	/* A wrapper around assuan_send_data which makes debugging the output
	* in verbose mode easier. It also takes CTRL as argument. */
	gpg_error_t
	kbxd_write_data_line (ctrl_t ctrl, const void *buffer_arg, size_t size)
	{
	const char *buffer = buffer_arg;
	assuan_context_t ctx = get_assuan_ctx_from_ctrl (ctrl);
	gpg_error_t err;

	if (!ctx) /* Oops - no assuan context. */
	return gpg_error (GPG_ERR_NOT_PROCESSED);

	/* Write toa file descriptor if enabled. */
	if (ctrl && ctrl->server_local && ctrl->server_local->outstream)
	{
	unsigned char lenbuf[4];

	ulongtobuf (lenbuf, size);
	err = kbxd_writen (ctrl->server_local->outstream, lenbuf, 4);
	if (!err)
	err = kbxd_writen (ctrl->server_local->outstream, buffer, size);
	if (!err && es_fflush (ctrl->server_local->outstream))
	{
	err = gpg_error_from_syserror ();
	log_error ("error writing OUTPUT: %s\n", gpg_strerror (err));
	}

	goto leave;
	}

	/* If we do not want logging, enable it here. */
	if (ctrl && ctrl->server_local && ctrl->server_local->inhibit_data_logging)
	ctrl->server_local->inhibit_data_logging_now = 1;

	if (0 && opt.verbose && buffer && size)
	{
	/* Ease reading of output by limiting the line length. */
	size_t n, nbytes;

	nbytes = size;
	do
	{
	n = nbytes > 64? 64 : nbytes;
	err = assuan_send_data (ctx, buffer, n);
	if (err)
	{
	gpg_err_set_errno (EIO);
	goto leave;
	}
	buffer += n;
	nbytes -= n;
	if (nbytes && (err=assuan_send_data (ctx, NULL, 0))) /* Flush line. */
	{
	gpg_err_set_errno (EIO);
	goto leave;
	}
	}
	while (nbytes);
	}
	else
	{
	err = assuan_send_data (ctx, buffer, size);
	if (err)
	{
	gpg_err_set_errno (EIO); /* For use by data_line_cookie_write. */
	goto leave;
	}
	}

	leave:
	if (ctrl && ctrl->server_local && ctrl->server_local->inhibit_data_logging)
	{
	ctrl->server_local->inhibit_data_logging_count += size;
	ctrl->server_local->inhibit_data_logging_now = 0;
	}

	return err;
	}



	/* Helper to print a message while leaving a command. */
	static gpg_error_t
	leave_cmd (assuan_context_t ctx, gpg_error_t err)
	{
	if (err && opt.verbose)
	{
	const char *name = assuan_get_command_name (ctx);
	if (!name)
	name = "?";
	if (gpg_err_source (err) == GPG_ERR_SOURCE_DEFAULT)
	log_error ("command '%s' failed: %s\n", name,
	gpg_strerror (err));
	else
	log_error ("command '%s' failed: %s <%s>\n", name,
	gpg_strerror (err), gpg_strsource (err));
	}
	return err;
	}



	/* Handle OPTION commands. */
	static gpg_error_t
	option_handler (assuan_context_t ctx, const char key, const char value)
	{
	ctrl_t ctrl = assuan_get_pointer (ctx);
	gpg_error_t err = 0;

	if (!strcmp (key, "lc-messages"))
	{
	if (ctrl->lc_messages)
	xfree (ctrl->lc_messages);
	ctrl->lc_messages = xtrystrdup (value);
	if (!ctrl->lc_messages)
	return out_of_core ();
	}
	else
	err = gpg_error (GPG_ERR_UNKNOWN_OPTION);

	return err;
	}



	static const char hlp_search[] =
	"SEARCH [--no-data] [[--more] PATTERN]\n"
	"\n"
	"Search for the keys identified by PATTERN. With --more more\n"
	"patterns to be used for the search are expected with the next\n"
	"command. With --no-data only the search status is returned but\n"
	"not the actual data. See also \"NEXT\".";
	static gpg_error_t
	cmd_search (assuan_context_t ctx, char *line)
	{
	ctrl_t ctrl = assuan_get_pointer (ctx);
	int opt_more, opt_no_data;
	gpg_error_t err;
	unsigned int n, k;

	opt_no_data = has_option (line, "--no-data");
	opt_more = has_option (line, "--more");
	line = skip_options (line);

	ctrl->server_local->search_any_found = 0;

	if (!*line)
	{
	if (opt_more)
	{
	err = set_error (GPG_ERR_INV_ARG, "--more but no pattern");
	goto leave;
	}
	else if (!*line && ctrl->server_local->search_expecting_more)
	{
	/* It would be too surprising to first set a pattern but
	* finally add no pattern to search the entire DB. */
	err = set_error (GPG_ERR_INV_ARG, "--more pending but no pattern");
	goto leave;
	}
	else /* No pattern - return the first item. */
	{
	memset (&ctrl->server_local->search_desc, 0,
	sizeof ctrl->server_local->search_desc);
	ctrl->server_local->search_desc.mode = KEYDB_SEARCH_MODE_FIRST;
	}
	}
	else
	{
	err = classify_user_id (line, &ctrl->server_local->search_desc, 0);
	if (err)
	goto leave;
	}

	if (opt_more \|\| ctrl->server_local->search_expecting_more)
	{
	/* More pattern are expected - store the current one and return
	* success. */
	if (!ctrl->server_local->multi_search_desc_size)
	{
	n = 10;
	ctrl->server_local->multi_search_desc
	= xtrycalloc (n, sizeof *ctrl->server_local->multi_search_desc);
	if (!ctrl->server_local->multi_search_desc)
	{
	err = gpg_error_from_syserror ();
	goto leave;
	}
	ctrl->server_local->multi_search_desc_size = n;
	}

	if (ctrl->server_local->multi_search_desc_len
	== ctrl->server_local->multi_search_desc_size)
	{
	KEYBOX_SEARCH_DESC *desc;
	n = ctrl->server_local->multi_search_desc_size + 10;
	desc = xtrycalloc (n, sizeof *desc);
	if (!desc)
	{
	err = gpg_error_from_syserror ();
	goto leave;
	}
	for (k=0; k < ctrl->server_local->multi_search_desc_size; k++)
	desc[k] = ctrl->server_local->multi_search_desc[k];
	xfree (ctrl->server_local->multi_search_desc);
	ctrl->server_local->multi_search_desc = desc;
	ctrl->server_local->multi_search_desc_size = n;
	}
	/* Actually store. */
	ctrl->server_local->multi_search_desc
	[ctrl->server_local->multi_search_desc_len++]
	= ctrl->server_local->search_desc;

	if (opt_more)
	{
	/* We need to be called aagain with more pattern. */
	ctrl->server_local->search_expecting_more = 1;
	goto leave;
	}
	ctrl->server_local->search_expecting_more = 0;
	/* Continue with the actual search. */
	}
	else
	ctrl->server_local->multi_search_desc_len = 0;

	ctrl->server_local->inhibit_data_logging = 1;
	ctrl->server_local->inhibit_data_logging_now = 0;
	ctrl->server_local->inhibit_data_logging_count = 0;
	ctrl->no_data_return = opt_no_data;
	err = prepare_outstream (ctrl);
	if (err)
	;
	else if (ctrl->server_local->multi_search_desc_len)
	err = kbxd_search (ctrl, ctrl->server_local->multi_search_desc,
	ctrl->server_local->multi_search_desc_len, 1);
	else
	err = kbxd_search (ctrl, &ctrl->server_local->search_desc, 1, 1);
	if (err)
	goto leave;

	/* Set a flag for use by NEXT. */
	ctrl->server_local->search_any_found = 1;

	leave:
	if (err)
	ctrl->server_local->multi_search_desc_len = 0;
	ctrl->no_data_return = 0;
	ctrl->server_local->inhibit_data_logging = 0;
	return leave_cmd (ctx, err);
	}


	static const char hlp_next[] =
	"NEXT [--no-data]\n"
	"\n"
	"Get the next search result from a previus search.";
	static gpg_error_t
	cmd_next (assuan_context_t ctx, char *line)
	{
	ctrl_t ctrl = assuan_get_pointer (ctx);
	int opt_no_data;
	gpg_error_t err;

	opt_no_data = has_option (line, "--no-data");
	line = skip_options (line);

	if (*line)
	{
	err = set_error (GPG_ERR_INV_ARG, "no args expected");
	goto leave;
	}

	if (!ctrl->server_local->search_any_found)
	{
	err = set_error (GPG_ERR_NOTHING_FOUND, "no previous SEARCH");
	goto leave;
	}

	ctrl->server_local->inhibit_data_logging = 1;
	ctrl->server_local->inhibit_data_logging_now = 0;
	ctrl->server_local->inhibit_data_logging_count = 0;
	ctrl->no_data_return = opt_no_data;
	err = prepare_outstream (ctrl);
	if (err)
	;
	else if (ctrl->server_local->multi_search_desc_len)
	{
	/* The next condition should never be tru but we better handle
	* the first/next transition anyway. */
	if (ctrl->server_local->multi_search_desc[0].mode
	== KEYDB_SEARCH_MODE_FIRST)
	ctrl->server_local->multi_search_desc[0].mode = KEYDB_SEARCH_MODE_NEXT;

	err = kbxd_search (ctrl, ctrl->server_local->multi_search_desc,
	ctrl->server_local->multi_search_desc_len, 0);
	}
	else
	{
	/* We need to do the transition from first to next here. */
	if (ctrl->server_local->search_desc.mode == KEYDB_SEARCH_MODE_FIRST)
	ctrl->server_local->search_desc.mode = KEYDB_SEARCH_MODE_NEXT;

	err = kbxd_search (ctrl, &ctrl->server_local->search_desc, 1, 0);
	}
	if (err)
	goto leave;

	leave:
	ctrl->no_data_return = 0;
	ctrl->server_local->inhibit_data_logging = 0;
	return leave_cmd (ctx, err);
	}


	static const char hlp_store[] =
	- "STORE [--update]\n"
	+ "STORE [--update\|--insert]\n"
	"\n"
	"Insert a key into the database. Whether to insert or update\n"
	"the key is decided by looking at the primary key's fingerprint.\n"
	- "With option --update the key must already exist. The actual key\n"
	- "material is requested by this function using\n"
	+ "With option --update the key must already exist.\n"
	+ "With option --insert the key must not already exist.\n"
	+ "The actual key material is requested by this function using\n"
	" INQUIRE BLOB";
	static gpg_error_t
	cmd_store (assuan_context_t ctx, char *line)
	{
	ctrl_t ctrl = assuan_get_pointer (ctx);
	- int opt_update;
	+ int opt_update, opt_insert;
	+ enum kbxd_store_modes mode;
	gpg_error_t err;
	unsigned char *value = NULL;
	size_t valuelen;

	opt_update = has_option (line, "--update");
	+ opt_insert = has_option (line, "--insert");
	line = skip_options (line);
	if (*line)
	{
	err = set_error (GPG_ERR_INV_ARG, "no args expected");
	goto leave;
	}
	+ if (opt_update && !opt_insert)
	+ mode = KBXD_STORE_UPDATE;
	+ else if (!opt_update && opt_insert)
	+ mode = KBXD_STORE_INSERT;
	+ else
	+ mode = KBXD_STORE_AUTO;

	/* Ask for the key material. */
	err = assuan_inquire (ctx, "BLOB", &value, &valuelen, 0);
	if (err)
	{
	log_error (_("assuan_inquire failed: %s\n"), gpg_strerror (err));
	goto leave;
	}

	if (!valuelen) /* No data received. */
	{
	err = gpg_error (GPG_ERR_MISSING_VALUE);
	goto leave;
	}

	- err = kbxd_store (ctrl, value, valuelen, opt_update);
	+ err = kbxd_store (ctrl, value, valuelen, mode);


	leave:
	xfree (value);
	return leave_cmd (ctx, err);
	}




	static const char hlp_getinfo[] =
	"GETINFO <what>\n"
	"\n"
	"Multi purpose command to return certain information. \n"
	"Supported values of WHAT are:\n"
	"\n"
	"version - Return the version of the program.\n"
	"pid - Return the process id of the server.\n"
	"socket_name - Return the name of the socket.\n"
	"session_id - Return the current session_id.\n"
	"getenv NAME - Return value of envvar NAME\n";
	static gpg_error_t
	cmd_getinfo (assuan_context_t ctx, char *line)
	{
	ctrl_t ctrl = assuan_get_pointer (ctx);
	gpg_error_t err;
	char numbuf[50];

	if (!strcmp (line, "version"))
	{
	const char *s = VERSION;
	err = assuan_send_data (ctx, s, strlen (s));
	}
	else if (!strcmp (line, "pid"))
	{
	snprintf (numbuf, sizeof numbuf, "%lu", (unsigned long)getpid ());
	err = assuan_send_data (ctx, numbuf, strlen (numbuf));
	}
	else if (!strcmp (line, "socket_name"))
	{
	const char *s = get_kbxd_socket_name ();
	if (!s)
	s = "[none]";
	err = assuan_send_data (ctx, s, strlen (s));
	}
	else if (!strcmp (line, "session_id"))
	{
	snprintf (numbuf, sizeof numbuf, "%u", ctrl->server_local->session_id);
	err = assuan_send_data (ctx, numbuf, strlen (numbuf));
	}
	else if (!strncmp (line, "getenv", 6)
	&& (line[6] == ' ' \|\| line[6] == '\t' \|\| !line[6]))
	{
	line += 6;
	while (line == ' ' \|\| line == '\t')
	line++;
	if (!*line)
	err = gpg_error (GPG_ERR_MISSING_VALUE);
	else
	{
	const char *s = getenv (line);
	if (!s)
	err = set_error (GPG_ERR_NOT_FOUND, "No such envvar");
	else
	err = assuan_send_data (ctx, s, strlen (s));
	}
	}
	else
	err = set_error (GPG_ERR_ASS_PARAMETER, "unknown value for WHAT");

	return leave_cmd (ctx, err);
	}



	static const char hlp_killkeyboxd[] =
	"KILLKEYBOXD\n"
	"\n"
	"This command allows a user - given sufficient permissions -\n"
	"to kill this keyboxd process.\n";
	static gpg_error_t
	cmd_killkeyboxd (assuan_context_t ctx, char *line)
	{
	ctrl_t ctrl = assuan_get_pointer (ctx);

	(void)line;

	ctrl->server_local->stopme = 1;
	assuan_set_flag (ctx, ASSUAN_FORCE_CLOSE, 1);
	return gpg_error (GPG_ERR_EOF);
	}


	static const char hlp_reloadkeyboxd[] =
	"RELOADKEYBOXD\n"
	"\n"
	"This command is an alternative to SIGHUP\n"
	"to reload the configuration.";
	static gpg_error_t
	cmd_reloadkeyboxd (assuan_context_t ctx, char *line)
	{
	(void)ctx;
	(void)line;

	kbxd_sighup_action ();
	return 0;
	}


	static const char hlp_output[] =
	"OUTPUT FD[=<n>]\n"
	"\n"
	"Set the file descriptor to write the output data to N. If N is not\n"
	"given and the operating system supports file descriptor passing, the\n"
	"file descriptor currently in flight will be used.";


	/* Tell the assuan library about our commands. */
	static int
	register_commands (assuan_context_t ctx)
	{
	static struct {
	const char *name;
	assuan_handler_t handler;
	const char * const help;
	} table[] = {
	{ "SEARCH", cmd_search, hlp_search },
	{ "NEXT", cmd_next, hlp_next },
	{ "STORE", cmd_store, hlp_store },
	{ "GETINFO", cmd_getinfo, hlp_getinfo },
	{ "OUTPUT", NULL, hlp_output },
	{ "KILLKEYBOXD",cmd_killkeyboxd,hlp_killkeyboxd },
	{ "RELOADKEYBOXD",cmd_reloadkeyboxd,hlp_reloadkeyboxd },
	{ NULL, NULL }
	};
	int i, j, rc;

	for (i=j=0; table[i].name; i++)
	{
	rc = assuan_register_command (ctx, table[i].name, table[i].handler,
	table[i].help);
	if (rc)
	return rc;
	}
	return 0;
	}


	/* Note that we do not reset the list of configured keyservers. */
	static gpg_error_t
	reset_notify (assuan_context_t ctx, char *line)
	{
	ctrl_t ctrl = assuan_get_pointer (ctx);

	(void)line;
	(void)ctrl;

	return 0;
	}


	/* This function is called by our assuan log handler to test whether a
	* log message shall really be printed. The function must return
	* false to inhibit the logging of MSG. CAT gives the requested log
	* category. MSG might be NULL. */
	int
	kbxd_assuan_log_monitor (assuan_context_t ctx, unsigned int cat,
	const char *msg)
	{
	ctrl_t ctrl = assuan_get_pointer (ctx);

	(void)cat;
	(void)msg;

	if (!ctrl \|\| !ctrl->server_local)
	return 1; /* Can't decide - allow logging. */

	if (!ctrl->server_local->inhibit_data_logging)
	return 1; /* Not requested - allow logging. */

	/* Disallow logging if _now is true. /
	return !ctrl->server_local->inhibit_data_logging_now;
	}


	/* Startup the server and run the main command loop. With FD = -1,
	* use stdin/stdout. SESSION_ID is either 0 or a unique number
	* identifying a session. */
	void
	kbxd_start_command_handler (ctrl_t ctrl, gnupg_fd_t fd, unsigned int session_id)
	{
	static const char hello[] = "Keyboxd " VERSION " at your service";
	static char *hello_line;
	int rc;
	assuan_context_t ctx;

	ctrl->server_local = xtrycalloc (1, sizeof *ctrl->server_local);
	if (!ctrl->server_local)
	{
	log_error (_("can't allocate control structure: %s\n"),
	gpg_strerror (gpg_error_from_syserror ()));
	xfree (ctrl);
	return;
	}

	rc = assuan_new (&ctx);
	if (rc)
	{
	log_error (_("failed to allocate assuan context: %s\n"),
	gpg_strerror (rc));
	kbxd_exit (2);
	}

	if (fd == GNUPG_INVALID_FD)
	{
	assuan_fd_t filedes[2];

	filedes[0] = assuan_fdopen (0);
	filedes[1] = assuan_fdopen (1);
	rc = assuan_init_pipe_server (ctx, filedes);
	}
	else
	{
	rc = assuan_init_socket_server (ctx, fd,
	(ASSUAN_SOCKET_SERVER_ACCEPTED
	\|ASSUAN_SOCKET_SERVER_FDPASSING));
	}

	if (rc)
	{
	assuan_release (ctx);
	log_error (_("failed to initialize the server: %s\n"),
	gpg_strerror (rc));
	kbxd_exit (2);
	}

	rc = register_commands (ctx);
	if (rc)
	{
	log_error (_("failed to the register commands with Assuan: %s\n"),
	gpg_strerror(rc));
	kbxd_exit (2);
	}


	if (!hello_line)
	{
	hello_line = xtryasprintf
	("Home: %s\n"
	"Config: %s\n"
	"%s",
	gnupg_homedir (),
	/opt.config_filename? opt.config_filename :/ "[none]",
	hello);
	}

	ctrl->server_local->assuan_ctx = ctx;
	assuan_set_pointer (ctx, ctrl);

	assuan_set_hello_line (ctx, hello_line);
	assuan_register_option_handler (ctx, option_handler);
	assuan_register_reset_notify (ctx, reset_notify);

	ctrl->server_local->session_id = session_id;

	/* The next call enable the use of status_printf. */
	set_assuan_context_func (get_assuan_ctx_from_ctrl);

	for (;;)
	{
	rc = assuan_accept (ctx);
	if (rc == -1)
	break;
	if (rc)
	{
	log_info (_("Assuan accept problem: %s\n"), gpg_strerror (rc));
	break;
	}

	#ifndef HAVE_W32_SYSTEM
	if (opt.verbose)
	{
	assuan_peercred_t peercred;

	if (!assuan_get_peercred (ctx, &peercred))
	log_info ("connection from process %ld (%ld:%ld)\n",
	(long)peercred->pid, (long)peercred->uid,
	(long)peercred->gid);
	}
	#endif

	rc = assuan_process (ctx);
	if (rc)
	{
	log_info (_("Assuan processing failed: %s\n"), gpg_strerror (rc));
	continue;
	}
	}

	assuan_close_output_fd (ctx);

	set_assuan_context_func (NULL);
	ctrl->server_local->assuan_ctx = NULL;
	assuan_release (ctx);

	if (ctrl->server_local->stopme)
	kbxd_exit (0);

	if (ctrl->refcount)
	log_error ("oops: connection control structure still referenced (%d)\n",
	ctrl->refcount);
	else
	{
	xfree (ctrl->server_local->multi_search_desc);
	xfree (ctrl->server_local);
	ctrl->server_local = NULL;
	}
	}
	diff --git a/kbx/keybox-blob.c b/kbx/keybox-blob.c
	index 0fced7e1c..b953e8c57 100644
	--- a/kbx/keybox-blob.c
	+++ b/kbx/keybox-blob.c
	@@ -1,1125 +1,1118 @@
	/* keybox-blob.c - KBX Blob handling
	* Copyright (C) 2000, 2001, 2002, 2003, 2008 Free Software Foundation, Inc.
	*
	* 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/>.
	*/

	/*
	* The keybox data format

	The KeyBox uses an augmented OpenPGP/X.509 key format. This makes
	random access to a keyblock/certificate easier and also gives the
	opportunity to store additional information (e.g. the fingerprint)
	along with the key. All integers are stored in network byte order,
	offsets are counted from the beginning of the Blob.

	** Overview of blob types

	\| Byte 4 \| Blob type \|
	\|--------+--------------\|
	\| 0 \| Empty blob \|
	\| 1 \| First blob \|
	\| 2 \| OpenPGP blob \|
	\| 3 \| X.509 blob \|

	** The First blob

	The first blob of a plain KBX file has a special format:

	- u32 Length of this blob
	- byte Blob type (1)
	- byte Version number (1)
	- u16 Header flags
	bit 0 - RFU
	bit 1 - Is being or has been used for OpenPGP blobs
	- b4 Magic 'KBXf'
	- u32 RFU
	- u32 file_created_at
	- u32 last_maintenance_run
	- u32 RFU
	- u32 RFU

	** The OpenPGP and X.509 blobs

	The OpenPGP and X.509 blobs are very similar, things which are
	X.509 specific are noted like [X.509: xxx]

	- u32 Length of this blob (including these 4 bytes)
	- byte Blob type
	2 = OpenPGP
	3 = X509
	- byte Version number of this blob type
	1 = Blob with 20 byte fingerprints
	2 = Blob with 32 byte fingerprints and no keyids.
	- u16 Blob flags
	bit 0 = contains secret key material (not used)
	bit 1 = ephemeral blob (e.g. used while querying external resources)
	- bit 2 = blob has an UBID field.
	- u32 Offset to the OpenPGP keyblock or the X.509 DER encoded
	certificate
	- u32 The length of the keyblock or certificate
	- u16 [NKEYS] Number of keys (at least 1!) [X509: always 1]
	- u16 Size of the key information structure (at least 28 or 56).
	- NKEYS times:
	Version 1 blob:
	- b20 The fingerprint of the key.
	Fingerprints are always 20 bytes, MD5 left padded with zeroes.
	- u32 Offset to the n-th key's keyID (a keyID is always 8 byte)
	or 0 if not known which is the case only for X.509.
	Note that this separate keyid is not anymore used by
	gnupg since the support for v3 keys has been removed.
	We create this field anyway for backward compatibility with
	old EOL-ed versions. Eventually we will completely move
	to the version 2 blob format.
	- u16 Key flags
	bit 0 = qualified signature (not yet implemented}
	- u16 RFU
	- bN Optional filler up to the specified length of this
	structure.
	Version 2 blob:
	- b32 The fingerprint of the key. This fingerprint is
	either 20 or 32 bytes. A 20 byte fingerprint is
	right filled with zeroes.
	- u16 Key flags
	bit 0 = qualified signature (not yet implemented}
	bit 7 = 32 byte fingerprint in use.
	- u16 RFU
	- b20 keygrip
	- bN Optional filler up to the specified length of this
	structure.
	- u16 Size of the serial number (may be zero)
	- bN The serial number. N as given above.
	- u16 Number of user IDs
	- u16 [NUIDS] Size of user ID information structure
	- NUIDS times:

	For X509, the first user ID is the Issuer, the second the
	Subject and the others are subjectAltNames. For OpenPGP we only
	store the information from UserID packets here.

	- u32 Blob offset to the n-th user ID
	- u32 Length of this user ID.
	- u16 User ID flags.
	(not yet used)
	- byte Validity
	- byte RFU

	- u16 [NSIGS] Number of signatures
	- u16 Size of signature information (4)
	- NSIGS times:
	- u32 Expiration time of signature with some special values.
	Since version 2.1.20 these special valuesare not anymore
	used for OpenPGP:
	- 0x00000000 = not checked
	- 0x00000001 = missing key
	- 0x00000002 = bad signature
	- 0x10000000 = valid and expires at some date in 1978.
	- 0xffffffff = valid and does not expire
	- u8 Assigned ownertrust [X509: not used]
	- u8 All_Validity
	OpenPGP: See ../g10/trustdb/TRUST_* [not yet used]
	X509: Bit 4 set := key has been revoked.
	Note that this value matches TRUST_FLAG_REVOKED
	- u16 RFU
	- u32 Recheck_after
	- u32 Latest timestamp in the keyblock (useful for KS synchronization?)
	- u32 Blob created at
	- u32 [NRES] Size of reserved space (not including this field)
	- bN Reserved space of size NRES for future use.
	- bN Arbitrary space for example used to store data which is not
	part of the keyblock or certificate. For example the v3 key
	IDs go here.
	- bN Space for the keyblock or certificate.
	- bN RFU. This is the remaining space after keyblock and before
	the checksum. Not part of the SHA-1 checksum.
	- - bN Only if blob flags bit 2 is set: 20 octet Unique Blob-ID (UBID).
	- This is the SHA-1 checksum of the keyblock or certificate.
	- This is not part of the SHA-1 checksum below.
	- b20 SHA-1 checksum (useful for KS synchronization?)
	Note, that KBX versions before GnuPG 2.1 used an MD5
	checksum. However it was only created but never checked.
	Thus we do not expect problems if we switch to SHA-1. If
	the checksum fails and the first 4 bytes are zero, we can
	try again with MD5. SHA-1 has the advantage that it is
	faster on CPUs with dedicated SHA-1 support.


	*/


	#include <config.h>
	#include <stdio.h>
	#include <stdlib.h>
	#include <string.h>
	#include <errno.h>
	#include <assert.h>
	#include <time.h>

	#include "keybox-defs.h"
	#include <gcrypt.h>

	#ifdef KEYBOX_WITH_X509
	#include <ksba.h>
	#endif


	#include "../common/gettime.h"
	#include "../common/host2net.h"


	#define get32(a) buf32_to_ulong ((a))


	/* special values of the signature status */
	#define SF_NONE(a) ( !(a) )
	#define SF_NOKEY(a) ((a) & (1<<0))
	#define SF_BAD(a) ((a) & (1<<1))
	#define SF_VALID(a) ((a) & (1<<29))


	struct membuf {
	size_t len;
	size_t size;
	char *buf;
	int out_of_core;
	};


	struct keyboxblob_key {
	char fpr[32];
	u32 off_kid;
	ulong off_kid_addr;
	u16 flags;
	u16 fprlen; /* Either 20 or 32 */
	};
	struct keyboxblob_uid {
	u32 off;
	ulong off_addr;
	char name; / used only with x509 */
	u32 len;
	u16 flags;
	byte validity;
	};

	struct keyid_list {
	struct keyid_list *next;
	int seqno;
	byte kid[8];
	};

	struct fixup_list {
	struct fixup_list *next;
	u32 off;
	u32 val;
	};


	struct keyboxblob {
	byte *blob;
	size_t bloblen;
	off_t fileoffset;

	/* stuff used only by keybox_create_blob */
	unsigned char *serialbuf;
	const unsigned char *serial;
	size_t seriallen;
	int nkeys;
	struct keyboxblob_key *keys;
	int nuids;
	struct keyboxblob_uid *uids;
	int nsigs;
	u32 *sigs;
	struct fixup_list *fixups;
	int fixup_out_of_core;

	struct keyid_list *temp_kids;
	struct membuf bufbuf; /* temporary store for the blob */
	struct membuf *buf;
	};



	/* A simple implementation of a dynamic buffer. Use init_membuf() to
	create a buffer, put_membuf to append bytes and get_membuf to
	release and return the buffer. Allocation errors are detected but
	only returned at the final get_membuf(), this helps not to clutter
	the code with out of core checks. */

	static void
	init_membuf (struct membuf *mb, int initiallen)
	{
	mb->len = 0;
	mb->size = initiallen;
	mb->out_of_core = 0;
	mb->buf = xtrymalloc (initiallen);
	if (!mb->buf)
	mb->out_of_core = 1;
	}

	static void
	put_membuf (struct membuf mb, const void buf, size_t len)
	{
	if (mb->out_of_core)
	return;

	if (mb->len + len >= mb->size)
	{
	char *p;

	mb->size += len + 1024;
	p = xtryrealloc (mb->buf, mb->size);
	if (!p)
	{
	mb->out_of_core = 1;
	return;
	}
	mb->buf = p;
	}
	if (buf)
	memcpy (mb->buf + mb->len, buf, len);
	else
	memset (mb->buf + mb->len, 0, len);
	mb->len += len;
	}

	static void *
	get_membuf (struct membuf mb, size_t len)
	{
	char *p;

	if (mb->out_of_core)
	{
	xfree (mb->buf);
	mb->buf = NULL;
	return NULL;
	}

	p = mb->buf;
	*len = mb->len;
	mb->buf = NULL;
	mb->out_of_core = 1; /* don't allow a reuse */
	return p;
	}


	static void
	put8 (struct membuf *mb, byte a )
	{
	put_membuf (mb, &a, 1);
	}

	static void
	put16 (struct membuf *mb, u16 a )
	{
	unsigned char tmp[2];
	tmp[0] = a>>8;
	tmp[1] = a;
	put_membuf (mb, tmp, 2);
	}

	static void
	put32 (struct membuf *mb, u32 a )
	{
	unsigned char tmp[4];
	tmp[0] = a>>24;
	tmp[1] = a>>16;
	tmp[2] = a>>8;
	tmp[3] = a;
	put_membuf (mb, tmp, 4);
	}



	/* Store a value in the fixup list */
	static void
	add_fixup (KEYBOXBLOB blob, u32 off, u32 val)
	{
	struct fixup_list *fl;

	if (blob->fixup_out_of_core)
	return;

	fl = xtrycalloc(1, sizeof *fl);
	if (!fl)
	blob->fixup_out_of_core = 1;
	else
	{
	fl->off = off;
	fl->val = val;
	fl->next = blob->fixups;
	blob->fixups = fl;
	}
	}



	/*
	OpenPGP specific stuff
	*/


	/* We must store the keyid at some place because we can't calculate
	the offset yet. This is only used for v3 keyIDs. Function returns
	an index value for later fixup or -1 for out of core. The value
	must be a non-zero value. */
	static int
	pgp_temp_store_kid (KEYBOXBLOB blob, struct _keybox_openpgp_key_info *kinfo)
	{
	struct keyid_list k, r;

	k = xtrymalloc (sizeof *k);
	if (!k)
	return -1;
	memcpy (k->kid, kinfo->keyid, 8);
	k->seqno = 0;
	k->next = blob->temp_kids;
	blob->temp_kids = k;
	for (r=k; r; r = r->next)
	k->seqno++;

	return k->seqno;
	}


	/* Helper for pgp_create_key_part. */
	static gpg_error_t
	pgp_create_key_part_single (KEYBOXBLOB blob, int n,
	struct _keybox_openpgp_key_info *kinfo)
	{
	size_t fprlen;
	int off;

	fprlen = kinfo->fprlen;
	memcpy (blob->keys[n].fpr, kinfo->fpr, fprlen);
	blob->keys[n].fprlen = fprlen;
	if (fprlen < 20) /* v3 fpr - shift right and fill with zeroes. */
	{
	memmove (blob->keys[n].fpr + 20 - fprlen, blob->keys[n].fpr, fprlen);
	memset (blob->keys[n].fpr, 0, 20 - fprlen);
	off = pgp_temp_store_kid (blob, kinfo);
	if (off == -1)
	return gpg_error_from_syserror ();
	blob->keys[n].off_kid = off;
	}
	else
	blob->keys[n].off_kid = 0; /* Will be fixed up later */
	blob->keys[n].flags = 0;
	return 0;
	}


	static gpg_error_t
	pgp_create_key_part (KEYBOXBLOB blob, keybox_openpgp_info_t info)
	{
	gpg_error_t err;
	int n = 0;
	struct _keybox_openpgp_key_info *kinfo;

	err = pgp_create_key_part_single (blob, n++, &info->primary);
	if (err)
	return err;
	if (info->nsubkeys)
	for (kinfo = &info->subkeys; kinfo; kinfo = kinfo->next)
	if ((err=pgp_create_key_part_single (blob, n++, kinfo)))
	return err;

	assert (n == blob->nkeys);
	return 0;
	}


	static void
	pgp_create_uid_part (KEYBOXBLOB blob, keybox_openpgp_info_t info)
	{
	int n = 0;
	struct _keybox_openpgp_uid_info *u;

	if (info->nuids)
	{
	for (u = &info->uids; u; u = u->next)
	{
	blob->uids[n].off = u->off;
	blob->uids[n].len = u->len;
	blob->uids[n].flags = 0;
	blob->uids[n].validity = 0;
	n++;
	}
	}

	assert (n == blob->nuids);
	}


	static void
	pgp_create_sig_part (KEYBOXBLOB blob, u32 *sigstatus)
	{
	int n;

	for (n=0; n < blob->nsigs; n++)
	{
	blob->sigs[n] = sigstatus? sigstatus[n+1] : 0;
	}
	}


	static int
	pgp_create_blob_keyblock (KEYBOXBLOB blob,
	const unsigned char *image, size_t imagelen)
	{
	struct membuf *a = blob->buf;
	int n;
	u32 kbstart = a->len;

	add_fixup (blob, 8, kbstart);

	for (n = 0; n < blob->nuids; n++)
	add_fixup (blob, blob->uids[n].off_addr, kbstart + blob->uids[n].off);

	put_membuf (a, image, imagelen);

	add_fixup (blob, 12, a->len - kbstart);
	return 0;
	}



	#ifdef KEYBOX_WITH_X509
	/*
	X.509 specific stuff
	*/

	/* Write the raw certificate out */
	static int
	x509_create_blob_cert (KEYBOXBLOB blob, ksba_cert_t cert)
	{
	struct membuf *a = blob->buf;
	const unsigned char *image;
	size_t length;
	u32 kbstart = a->len;

	/* Store our offset for later fixup */
	add_fixup (blob, 8, kbstart);

	image = ksba_cert_get_image (cert, &length);
	if (!image)
	return gpg_error (GPG_ERR_GENERAL);
	put_membuf (a, image, length);

	add_fixup (blob, 12, a->len - kbstart);
	return 0;
	}

	#endif /KEYBOX_WITH_X509/

	/* Write a stored keyID out to the buffer */
	static void
	write_stored_kid (KEYBOXBLOB blob, int seqno)
	{
	struct keyid_list *r;

	for ( r = blob->temp_kids; r; r = r->next )
	{
	if (r->seqno == seqno )
	{
	put_membuf (blob->buf, r->kid, 8);
	return;
	}
	}
	never_reached ();
	}

	/* Release a list of key IDs */
	static void
	release_kid_list (struct keyid_list *kl)
	{
	struct keyid_list r, r2;

	for ( r = kl; r; r = r2 )
	{
	r2 = r->next;
	xfree (r);
	}
	}


	/* Create a new blob header. If WANT_FPR32 is set a version 2 blob is
	* created. */
	static int
	create_blob_header (KEYBOXBLOB blob, int blobtype, int as_ephemeral,
	int want_fpr32)
	{
	struct membuf *a = blob->buf;
	int i;

	put32 ( a, 0 ); /* blob length, needs fixup */
	put8 ( a, blobtype);
	put8 ( a, want_fpr32? 2:1 ); /* blob type version */
	put16 ( a, as_ephemeral? 6:4 ); /* blob flags */

	put32 ( a, 0 ); /* offset to the raw data, needs fixup */
	put32 ( a, 0 ); /* length of the raw data, needs fixup */

	put16 ( a, blob->nkeys );
	if (want_fpr32)
	put16 ( a, 32 + 2 + 2 + 20); /* size of key info */
	else
	put16 ( a, 20 + 4 + 2 + 2 ); /* size of key info */
	for ( i=0; i < blob->nkeys; i++ )
	{
	if (want_fpr32)
	{
	put_membuf (a, blob->keys[i].fpr, blob->keys[i].fprlen);
	blob->keys[i].off_kid_addr = a->len;
	if (blob->keys[i].fprlen == 32)
	put16 ( a, (blob->keys[i].flags \| 0x80));
	else
	put16 ( a, blob->keys[i].flags);
	put16 ( a, 0 ); /* reserved */
	/* FIXME: Put the real grip here instead of the filler. */
	put_membuf (a, "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0", 20);
	}
	else
	{
	log_assert (blob->keys[i].fprlen <= 20);
	put_membuf (a, blob->keys[i].fpr, 20);
	blob->keys[i].off_kid_addr = a->len;
	put32 ( a, 0 ); /* offset to keyid, fixed up later */
	put16 ( a, blob->keys[i].flags );
	put16 ( a, 0 ); /* reserved */
	}
	}

	put16 (a, blob->seriallen); /fixme: check that it fits into 16 bits/
	if (blob->serial)
	put_membuf (a, blob->serial, blob->seriallen);

	put16 ( a, blob->nuids );
	put16 ( a, 4 + 4 + 2 + 1 + 1 ); /* size of uid info */
	for (i=0; i < blob->nuids; i++)
	{
	blob->uids[i].off_addr = a->len;
	put32 ( a, 0 ); /* offset to userid, fixed up later */
	put32 ( a, blob->uids[i].len );
	put16 ( a, blob->uids[i].flags );
	put8 ( a, 0 ); /* validity */
	put8 ( a, 0 ); /* reserved */
	}

	put16 ( a, blob->nsigs );
	put16 ( a, 4 ); /* size of sig info */
	for (i=0; i < blob->nsigs; i++)
	{
	put32 ( a, blob->sigs[i]);
	}

	put8 ( a, 0 ); /* assigned ownertrust */
	put8 ( a, 0 ); /* validity of all user IDs */
	put16 ( a, 0 ); /* reserved */
	put32 ( a, 0 ); /* time of next recheck */
	put32 ( a, 0 ); /* newest timestamp (none) */
	put32 ( a, make_timestamp() ); /* creation time */
	put32 ( a, 0 ); /* size of reserved space */
	/* reserved space (which is currently of size 0) */

	/* space where we write keyIDs and other stuff so that the
	pointers can actually point to somewhere */
	if (blobtype == KEYBOX_BLOBTYPE_PGP && !want_fpr32)
	{
	/* For version 1 blobs, we need to store the keyids for all v3
	* keys because those key IDs are not part of the fingerprint.
	* While we are doing that, we fixup all the keyID offsets. For
	* version 2 blobs (which can't carry v3 keys) we compute the
	* keyids in the fly because they are just stripped down
	* fingerprints. */
	for (i=0; i < blob->nkeys; i++ )
	{
	if (blob->keys[i].off_kid)
	{ /* this is a v3 one */
	add_fixup (blob, blob->keys[i].off_kid_addr, a->len);
	write_stored_kid (blob, blob->keys[i].off_kid);
	}
	else
	{ /* the better v4 key IDs - just store an offset 8 bytes back */
	add_fixup (blob, blob->keys[i].off_kid_addr,
	blob->keys[i].off_kid_addr - 8);
	}
	}
	}

	if (blobtype == KEYBOX_BLOBTYPE_X509)
	{
	/* We don't want to point to ASN.1 encoded UserIDs (DNs) but to
	the utf-8 string representation of them */
	for (i=0; i < blob->nuids; i++ )
	{
	if (blob->uids[i].name)
	{ /* this is a v3 one */
	add_fixup (blob, blob->uids[i].off_addr, a->len);
	put_membuf (blob->buf, blob->uids[i].name, blob->uids[i].len);
	}
	}
	}

	return 0;
	}



	static int
	create_blob_trailer (KEYBOXBLOB blob)
	{
	(void)blob;
	return 0;
	}


	static int
	create_blob_finish (KEYBOXBLOB blob)
	{
	struct membuf *a = blob->buf;
	unsigned char *p;
	unsigned char *pp;
	size_t n;

	- /* Write placeholders for the UBID and the checksum */
	- put_membuf (a, NULL, 40);
	+ /* Write placeholders for the checksum. */
	+ put_membuf (a, NULL, 20);

	/* get the memory area */
	n = 0; /* (Just to avoid compiler warning.) */
	p = get_membuf (a, &n);
	if (!p)
	return gpg_error (GPG_ERR_ENOMEM);
	assert (n >= 20);

	/* fixup the length */
	add_fixup (blob, 0, n);

	/* do the fixups */
	if (blob->fixup_out_of_core)
	{
	xfree (p);
	return gpg_error (GPG_ERR_ENOMEM);
	}

	{
	struct fixup_list fl, next;
	for (fl = blob->fixups; fl; fl = next)
	{
	assert (fl->off+4 <= n);
	p[fl->off+0] = fl->val >> 24;
	p[fl->off+1] = fl->val >> 16;
	p[fl->off+2] = fl->val >> 8;
	p[fl->off+3] = fl->val;
	next = fl->next;
	xfree (fl);
	}
	blob->fixups = NULL;
	}

	- /* Compute and store the UBID. (image_off) (image_len) */
	- gcry_md_hash_buffer (GCRY_MD_SHA1, p + n - 40, p + get32 (p+8), get32 (p+12));
	-
	/* Compute and store the SHA-1 checksum. */
	gcry_md_hash_buffer (GCRY_MD_SHA1, p + n - 20, p, n - 40);

	pp = xtrymalloc (n);
	if ( !pp )
	{
	xfree (p);
	return gpg_error_from_syserror ();
	}
	memcpy (pp , p, n);
	xfree (p);
	blob->blob = pp;
	blob->bloblen = n;

	return 0;
	}



	gpg_error_t
	_keybox_create_openpgp_blob (KEYBOXBLOB *r_blob,
	keybox_openpgp_info_t info,
	const unsigned char *image,
	size_t imagelen,
	int as_ephemeral)
	{
	gpg_error_t err;
	KEYBOXBLOB blob;
	int need_fpr32 = 0;

	*r_blob = NULL;


	/* Check whether we need a blob with 32 bit fingerprints. We could
	* use this always but for backward compatiblity we do this only for
	* v5 keys. */
	if (info->primary.version == 5)
	need_fpr32 = 1;
	else
	{
	struct _keybox_openpgp_key_info *kinfo;
	for (kinfo = &info->subkeys; kinfo; kinfo = kinfo->next)
	if (kinfo->version == 5)
	{
	need_fpr32 = 1;
	break;
	}
	}

	blob = xtrycalloc (1, sizeof *blob);
	if (!blob)
	return gpg_error_from_syserror ();

	blob->nkeys = 1 + info->nsubkeys;
	blob->keys = xtrycalloc (blob->nkeys, sizeof *blob->keys );
	if (!blob->keys)
	{
	err = gpg_error_from_syserror ();
	goto leave;
	}

	blob->nuids = info->nuids;
	if (blob->nuids)
	{
	blob->uids = xtrycalloc (blob->nuids, sizeof *blob->uids );
	if (!blob->uids)
	{
	err = gpg_error_from_syserror ();
	goto leave;
	}
	}

	blob->nsigs = info->nsigs;
	if (blob->nsigs)
	{
	blob->sigs = xtrycalloc (blob->nsigs, sizeof *blob->sigs );
	if (!blob->sigs)
	{
	err = gpg_error_from_syserror ();
	goto leave;
	}
	}

	err = pgp_create_key_part (blob, info);
	if (err)
	goto leave;
	pgp_create_uid_part (blob, info);
	pgp_create_sig_part (blob, NULL);

	init_membuf (&blob->bufbuf, 1024);
	blob->buf = &blob->bufbuf;
	err = create_blob_header (blob, KEYBOX_BLOBTYPE_PGP,
	as_ephemeral, need_fpr32);
	if (err)
	goto leave;
	err = pgp_create_blob_keyblock (blob, image, imagelen);
	if (err)
	goto leave;
	err = create_blob_trailer (blob);
	if (err)
	goto leave;
	err = create_blob_finish (blob);
	if (err)
	goto leave;

	leave:
	release_kid_list (blob->temp_kids);
	blob->temp_kids = NULL;
	if (err)
	_keybox_release_blob (blob);
	else
	*r_blob = blob;
	return err;
	}


	#ifdef KEYBOX_WITH_X509

	/* Return an allocated string with the email address extracted from a
	DN. Note hat we use this code also in ../sm/keylist.c. */
	static char *
	x509_email_kludge (const char *name)
	{
	const char p, string;
	unsigned char *buf;
	int n;

	string = name;
	for (;;)
	{
	p = strstr (string, "1.2.840.113549.1.9.1=#");
	if (!p)
	return NULL;
	if (p == name \|\| (p > string+1 && p[-1] == ',' && p[-2] != '\\'))
	{
	name = p + 22;
	break;
	}
	string = p + 22;
	}


	/* This looks pretty much like an email address in the subject's DN
	we use this to add an additional user ID entry. This way,
	OpenSSL generated keys get a nicer and usable listing. */
	for (n=0, p=name; hexdigitp (p) && hexdigitp (p+1); p +=2, n++)
	;
	if (!n)
	return NULL;
	buf = xtrymalloc (n+3);
	if (!buf)
	return NULL; /* oops, out of core */
	*buf = '<';
	for (n=1, p=name; hexdigitp (p); p +=2, n++)
	buf[n] = xtoi_2 (p);
	buf[n++] = '>';
	buf[n] = 0;
	return (char*)buf;
	}



	/* Note: We should move calculation of the digest into libksba and
	remove that parameter */
	int
	_keybox_create_x509_blob (KEYBOXBLOB *r_blob, ksba_cert_t cert,
	unsigned char *sha1_digest, int as_ephemeral)
	{
	int i, rc = 0;
	KEYBOXBLOB blob;
	unsigned char *sn;
	char *p;
	char **names = NULL;
	size_t max_names;

	*r_blob = NULL;
	blob = xtrycalloc (1, sizeof *blob);
	if( !blob )
	return gpg_error_from_syserror ();

	sn = ksba_cert_get_serial (cert);
	if (sn)
	{
	size_t n, len;
	n = gcry_sexp_canon_len (sn, 0, NULL, NULL);
	if (n < 2)
	{
	xfree (sn);
	return gpg_error (GPG_ERR_GENERAL);
	}
	blob->serialbuf = sn;
	sn++; n--; /* skip '(' */
	for (len=0; n && sn && sn != ':' && digitp (sn); n--, sn++)
	len = len*10 + atoi_1 (sn);
	if (*sn != ':')
	{
	xfree (blob->serialbuf);
	blob->serialbuf = NULL;
	return gpg_error (GPG_ERR_GENERAL);
	}
	sn++;
	blob->serial = sn;
	blob->seriallen = len;
	}

	blob->nkeys = 1;

	/* create list of names */
	blob->nuids = 0;
	max_names = 100;
	names = xtrymalloc (max_names * sizeof *names);
	if (!names)
	{
	rc = gpg_error_from_syserror ();
	goto leave;
	}

	p = ksba_cert_get_issuer (cert, 0);
	if (!p)
	{
	rc = gpg_error (GPG_ERR_MISSING_VALUE);
	goto leave;
	}
	names[blob->nuids++] = p;
	for (i=0; (p = ksba_cert_get_subject (cert, i)); i++)
	{
	if (blob->nuids >= max_names)
	{
	char **tmp;

	max_names += 100;
	tmp = xtryrealloc (names, max_names * sizeof *names);
	if (!tmp)
	{
	rc = gpg_error_from_syserror ();
	goto leave;
	}
	names = tmp;
	}
	names[blob->nuids++] = p;
	if (!i && (p=x509_email_kludge (p)))
	names[blob->nuids++] = p; /* due to !i we don't need to check bounds*/
	}

	/* space for signature information */
	blob->nsigs = 1;

	blob->keys = xtrycalloc (blob->nkeys, sizeof *blob->keys );
	blob->uids = xtrycalloc (blob->nuids, sizeof *blob->uids );
	blob->sigs = xtrycalloc (blob->nsigs, sizeof *blob->sigs );
	if (!blob->keys \|\| !blob->uids \|\| !blob->sigs)
	{
	rc = gpg_error (GPG_ERR_ENOMEM);
	goto leave;
	}

	memcpy (blob->keys[0].fpr, sha1_digest, 20);
	blob->keys[0].off_kid = 0; /* We don't have keyids */
	blob->keys[0].flags = 0;

	/* issuer and subject names */
	for (i=0; i < blob->nuids; i++)
	{
	blob->uids[i].name = names[i];
	blob->uids[i].len = strlen(names[i]);
	names[i] = NULL;
	blob->uids[i].flags = 0;
	blob->uids[i].validity = 0;
	}
	xfree (names);
	names = NULL;

	/* signatures */
	blob->sigs[0] = 0; /* not yet checked */

	/* Create a temporary buffer for further processing */
	init_membuf (&blob->bufbuf, 1024);
	blob->buf = &blob->bufbuf;
	/* write out what we already have */
	rc = create_blob_header (blob, KEYBOX_BLOBTYPE_X509, as_ephemeral, 0);
	if (rc)
	goto leave;
	rc = x509_create_blob_cert (blob, cert);
	if (rc)
	goto leave;
	rc = create_blob_trailer (blob);
	if (rc)
	goto leave;
	rc = create_blob_finish ( blob );
	if (rc)
	goto leave;


	leave:
	release_kid_list (blob->temp_kids);
	blob->temp_kids = NULL;
	if (names)
	{
	for (i=0; i < blob->nuids; i++)
	xfree (names[i]);
	xfree (names);
	}
	if (rc)
	{
	_keybox_release_blob (blob);
	*r_blob = NULL;
	}
	else
	{
	*r_blob = blob;
	}
	return rc;
	}
	#endif /KEYBOX_WITH_X509/



	int
	_keybox_new_blob (KEYBOXBLOB *r_blob,
	unsigned char *image, size_t imagelen, off_t off)
	{
	KEYBOXBLOB blob;

	*r_blob = NULL;
	blob = xtrycalloc (1, sizeof *blob);
	if (!blob)
	return gpg_error_from_syserror ();

	blob->blob = image;
	blob->bloblen = imagelen;
	blob->fileoffset = off;
	*r_blob = blob;
	return 0;
	}


	void
	_keybox_release_blob (KEYBOXBLOB blob)
	{
	int i;
	if (!blob)
	return;
	if (blob->buf)
	{
	size_t len;
	xfree (get_membuf (blob->buf, &len));
	}
	xfree (blob->keys );
	xfree (blob->serialbuf);
	for (i=0; i < blob->nuids; i++)
	xfree (blob->uids[i].name);
	xfree (blob->uids );
	xfree (blob->sigs );
	xfree (blob->blob );
	xfree (blob );
	}



	const unsigned char *
	_keybox_get_blob_image ( KEYBOXBLOB blob, size_t *n )
	{
	*n = blob->bloblen;
	return blob->blob;
	}

	off_t
	_keybox_get_blob_fileoffset (KEYBOXBLOB blob)
	{
	return blob->fileoffset;
	}



	void
	_keybox_update_header_blob (KEYBOXBLOB blob, int for_openpgp)
	{
	if (blob->bloblen >= 32 && blob->blob[4] == KEYBOX_BLOBTYPE_HEADER)
	{
	u32 val = make_timestamp ();

	/* Update the last maintenance run timestamp. */
	blob->blob[20] = (val >> 24);
	blob->blob[20+1] = (val >> 16);
	blob->blob[20+2] = (val >> 8);
	blob->blob[20+3] = (val );

	if (for_openpgp)
	blob->blob[7] \|= 0x02; /* OpenPGP data may be available. */
	}
	}
	diff --git a/kbx/keybox-dump.c b/kbx/keybox-dump.c
	index 55a47a403..0c289d50a 100644
	--- a/kbx/keybox-dump.c
	+++ b/kbx/keybox-dump.c
	@@ -1,868 +1,822 @@
	/* keybox-dump.c - Debug helpers
	* Copyright (C) 2001, 2003 Free Software Foundation, Inc.
	*
	* 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 <stdlib.h>
	#include <stdio.h>
	#include <string.h>
	#include <errno.h>

	#include "keybox-defs.h"
	#include <gcrypt.h>
	#include "../common/host2net.h"

	/* Argg, we can't include ../common/util.h */
	char bin2hexcolon (const void buffer, size_t length, char *stringbuf);

	#define get32(a) buf32_to_ulong ((a))
	#define get16(a) buf16_to_ulong ((a))


	void
	print_string (FILE fp, const byte p, size_t n, int delim)
	{
	for ( ; n; n--, p++ )
	{
	if (p < 0x20 \|\| (p >= 0x7f && p < 0xa0) \|\| p == delim)
	{
	putc('\\', fp);
	if( *p == '\n' )
	putc('n', fp);
	else if( *p == '\r' )
	putc('r', fp);
	else if( *p == '\f' )
	putc('f', fp);
	else if( *p == '\v' )
	putc('v', fp);
	else if( *p == '\b' )
	putc('b', fp);
	else if( !*p )
	putc('0', fp);
	else
	fprintf(fp, "x%02x", *p );
	}
	else
	putc(*p, fp);
	}
	}


	-static void
	-print_ubib (const byte buffer, size_t length, FILE fp)
	-{
	- const byte *p;
	- int i;
	- size_t image_off, image_len;
	- unsigned char digest[20];
	-
	- fprintf (fp, "UBIB: ");
	- if (length < 40)
	- {
	- fputs ("[blob too short for a stored UBIB]\n", fp);
	- return;
	- }
	-
	- p = buffer + length - 40;
	- for (i=0; i < 20; p++, i++)
	- fprintf (fp, "%02X", *p);
	-
	- image_off = get32 (buffer+8);
	- image_len = get32 (buffer+12);
	- if ((uint64_t)image_off+(uint64_t)image_len > (uint64_t)length)
	- {
	- fputs (" [image claims to be longer than the blob]\n", fp);
	- return;
	- }
	-
	- gcry_md_hash_buffer (GCRY_MD_SHA1, digest, buffer+image_off,image_len);
	- if (memcmp (digest, buffer + length - 40, 20))
	- fputs (" [does not match the image]\n", fp);
	- else
	- fputc ('\n', fp);
	-}
	-
	-
	static int
	print_checksum (const byte buffer, size_t length, size_t unhashed, FILE fp)
	{
	const byte *p;
	int i;
	int hashlen;
	unsigned char digest[20];

	fprintf (fp, "Checksum: ");
	if (unhashed && unhashed < 20)
	{
	fputs ("[specified unhashed sized too short]\n", fp);
	return 0;
	}
	if (!unhashed)
	{
	unhashed = 16;
	hashlen = 16;
	}
	else
	hashlen = 20;
	if (length < 5+unhashed)
	{
	fputs ("[blob too short for a checksum]\n", fp);
	return 0;
	}

	p = buffer + length - hashlen;
	for (i=0; i < hashlen; p++, i++)
	fprintf (fp, "%02x", *p);

	if (hashlen == 16) /* Compatibility method. */
	{
	gcry_md_hash_buffer (GCRY_MD_MD5, digest, buffer, length - 16);
	if (!memcmp (buffer + length - 16, digest, 16))
	fputs (" [valid]\n", fp);
	else
	fputs (" [bad]\n", fp);
	}
	else
	{
	gcry_md_hash_buffer (GCRY_MD_SHA1, digest, buffer, length - unhashed);
	if (!memcmp (buffer + length - hashlen, digest, hashlen))
	fputs (" [valid]\n", fp);
	else
	fputs (" [bad]\n", fp);
	}
	return 0;
	}


	static int
	dump_header_blob (const byte buffer, size_t length, FILE fp)
	{
	unsigned long n;

	if (length < 32)
	{
	fprintf (fp, "[blob too short]\n");
	return -1;
	}
	fprintf (fp, "Version: %d\n", buffer[5]);

	n = get16 (buffer + 6);
	fprintf( fp, "Flags: %04lX", n);
	if (n)
	{
	int any = 0;

	fputs (" (", fp);
	if ((n & 2))
	{
	if (any)
	putc (',', fp);
	fputs ("openpgp", fp);
	any++;
	}
	putc (')', fp);
	}
	putc ('\n', fp);

	if ( memcmp (buffer+8, "KBXf", 4))
	fprintf (fp, "[Error: invalid magic number]\n");

	n = get32 (buffer+16);
	fprintf( fp, "created-at: %lu\n", n );
	n = get32 (buffer+20);
	fprintf( fp, "last-maint: %lu\n", n );

	return 0;
	}


	/* Dump one block to FP */
	int
	_keybox_dump_blob (KEYBOXBLOB blob, FILE *fp)
	{
	const byte *buffer;
	size_t length;
	int type, i;
	ulong n, nkeys, keyinfolen;
	ulong nuids, uidinfolen;
	ulong nsigs, siginfolen;
	ulong rawdata_off, rawdata_len;
	ulong nserial;
	ulong unhashed;
	const byte *p;
	- int is_fpr32; /* blob ersion 2 */
	- int have_ubib = 0;
	+ int is_fpr32; /* blob version 2 */

	buffer = _keybox_get_blob_image (blob, &length);

	if (length < 32)
	{
	fprintf (fp, "[blob too short]\n");
	return -1;
	}

	n = get32( buffer );
	if (n > length)
	fprintf (fp, "[blob larger than length - output truncated]\n");
	else
	length = n; /* ignore the rest */

	fprintf (fp, "Length: %lu\n", n );
	type = buffer[4];
	switch (type)
	{
	case KEYBOX_BLOBTYPE_EMPTY:
	fprintf (fp, "Type: Empty\n");
	return 0;

	case KEYBOX_BLOBTYPE_HEADER:
	fprintf (fp, "Type: Header\n");
	return dump_header_blob (buffer, length, fp);
	case KEYBOX_BLOBTYPE_PGP:
	fprintf (fp, "Type: OpenPGP\n");
	break;
	case KEYBOX_BLOBTYPE_X509:
	fprintf (fp, "Type: X.509\n");
	break;
	default:
	fprintf (fp, "Type: %d\n", type);
	fprintf (fp, "[can't dump this blob type]\n");
	return 0;
	}
	/* Here we have either BLOGTYPE_X509 or BLOBTYPE_OPENPGP */
	fprintf (fp, "Version: %d\n", buffer[5]);
	is_fpr32 = buffer[5] == 2;

	if (length < 40)
	{
	fprintf (fp, "[blob too short]\n");
	return -1;
	}

	n = get16 (buffer + 6);
	fprintf( fp, "Blob-Flags: %04lX", n);
	if (n)
	{
	int any = 0;

	fputs (" (", fp);
	if ((n & 1))
	{
	fputs ("secret", fp);
	any++;
	}
	if ((n & 2))
	{
	if (any)
	putc (',', fp);
	fputs ("ephemeral", fp);
	any++;
	}
	- if ((n & 4))
	- {
	- if (any)
	- putc (',', fp);
	- fputs ("ubid", fp);
	- any++;
	- have_ubib = 1;
	- }
	putc (')', fp);
	}
	putc ('\n', fp);

	rawdata_off = get32 (buffer + 8);
	rawdata_len = get32 (buffer + 12);

	fprintf( fp, "Data-Offset: %lu\n", rawdata_off );
	fprintf( fp, "Data-Length: %lu\n", rawdata_len );
	if (rawdata_off > length \|\| rawdata_len > length
	\|\| rawdata_off+rawdata_len > length
	\|\| rawdata_len + 4 > length
	\|\| rawdata_off+rawdata_len + 4 > length)
	fprintf (fp, "[Error: raw data larger than blob]\n");
	unhashed = length - rawdata_off - rawdata_len;
	fprintf (fp, "Unhashed: %lu\n", unhashed);

	nkeys = get16 (buffer + 16);
	fprintf (fp, "Key-Count: %lu\n", nkeys );
	if (!nkeys)
	fprintf (fp, "[Error: no keys]\n");
	if (nkeys > 1 && type == KEYBOX_BLOBTYPE_X509)
	fprintf (fp, "[Error: only one key allowed for X509]\n");

	keyinfolen = get16 (buffer + 18 );
	fprintf (fp, "Key-Info-Length: %lu\n", keyinfolen);
	/* fixme: check bounds */
	p = buffer + 20;
	for (n=0; n < nkeys; n++, p += keyinfolen)
	{
	ulong kidoff, kflags;

	fprintf (fp, "Key-Fpr[%lu]: ", n );
	if (is_fpr32)
	{
	kflags = get16 (p + 32 );
	for (i=0; i < ((kflags & 0x80)?32:20); i++ )
	fprintf (fp, "%02X", p[i]);
	}
	else
	{
	for (i=0; i < 20; i++ )
	fprintf (fp, "%02X", p[i]);
	kidoff = get32 (p + 20);
	fprintf (fp, "\nKey-Kid-Off[%lu]: %lu\n", n, kidoff );
	fprintf (fp, "Key-Kid[%lu]: ", n );
	/* fixme: check bounds */
	for (i=0; i < 8; i++ )
	fprintf (fp, "%02X", buffer[kidoff+i] );
	kflags = get16 (p + 24 );
	}
	fprintf( fp, "\nKey-Flags[%lu]: %04lX\n", n, kflags);
	}

	/* serial number */
	fputs ("Serial-No: ", fp);
	nserial = get16 (p);
	p += 2;
	if (!nserial)
	fputs ("none", fp);
	else
	{
	for (; nserial; nserial--, p++)
	fprintf (fp, "%02X", *p);
	}
	putc ('\n', fp);

	/* user IDs */
	nuids = get16 (p);
	fprintf (fp, "Uid-Count: %lu\n", nuids );
	uidinfolen = get16 (p + 2);
	fprintf (fp, "Uid-Info-Length: %lu\n", uidinfolen);
	/* fixme: check bounds */
	p += 4;
	for (n=0; n < nuids; n++, p += uidinfolen)
	{
	ulong uidoff, uidlen, uflags;

	uidoff = get32( p );
	uidlen = get32( p+4 );
	if (type == KEYBOX_BLOBTYPE_X509 && !n)
	{
	fprintf (fp, "Issuer-Off: %lu\n", uidoff );
	fprintf (fp, "Issuer-Len: %lu\n", uidlen );
	fprintf (fp, "Issuer: \"");
	}
	else if (type == KEYBOX_BLOBTYPE_X509 && n == 1)
	{
	fprintf (fp, "Subject-Off: %lu\n", uidoff );
	fprintf (fp, "Subject-Len: %lu\n", uidlen );
	fprintf (fp, "Subject: \"");
	}
	else
	{
	fprintf (fp, "Uid-Off[%lu]: %lu\n", n, uidoff );
	fprintf (fp, "Uid-Len[%lu]: %lu\n", n, uidlen );
	fprintf (fp, "Uid[%lu]: \"", n );
	}
	print_string (fp, buffer+uidoff, uidlen, '\"');
	fputs ("\"\n", fp);
	uflags = get16 (p + 8);
	if (type == KEYBOX_BLOBTYPE_X509 && !n)
	{
	fprintf (fp, "Issuer-Flags: %04lX\n", uflags );
	fprintf (fp, "Issuer-Validity: %d\n", p[10] );
	}
	else if (type == KEYBOX_BLOBTYPE_X509 && n == 1)
	{
	fprintf (fp, "Subject-Flags: %04lX\n", uflags );
	fprintf (fp, "Subject-Validity: %d\n", p[10] );
	}
	else
	{
	fprintf (fp, "Uid-Flags[%lu]: %04lX\n", n, uflags );
	fprintf (fp, "Uid-Validity[%lu]: %d\n", n, p[10] );
	}
	}

	nsigs = get16 (p);
	fprintf (fp, "Sig-Count: %lu\n", nsigs );
	siginfolen = get16 (p + 2);
	fprintf (fp, "Sig-Info-Length: %lu\n", siginfolen );
	/* fixme: check bounds */
	p += 4;
	{
	int in_range = 0;
	ulong first = 0;

	for (n=0; n < nsigs; n++, p += siginfolen)
	{
	ulong sflags;

	sflags = get32 (p);
	if (!in_range && !sflags)
	{
	in_range = 1;
	first = n;
	continue;
	}
	if (in_range && !sflags)
	continue;
	if (in_range)
	{
	fprintf (fp, "Sig-Expire[%lu-%lu]: [not checked]\n", first, n-1);
	in_range = 0;
	}

	fprintf (fp, "Sig-Expire[%lu]: ", n );
	if (!sflags)
	fputs ("[not checked]", fp);
	else if (sflags == 1 )
	fputs ("[missing key]", fp);
	else if (sflags == 2 )
	fputs ("[bad signature]", fp);
	else if (sflags < 0x10000000)
	fprintf (fp, "[bad flag %0lx]", sflags);
	else if (sflags == (ulong)(-1))
	fputs ("[good - does not expire]", fp );
	else
	fprintf (fp, "[good - expires at %lu]", sflags);
	putc ('\n', fp );
	}
	if (in_range)
	fprintf (fp, "Sig-Expire[%lu-%lu]: [not checked]\n", first, n-1);
	}
	fprintf (fp, "Ownertrust: %d\n", p[0] );
	fprintf (fp, "All-Validity: %d\n", p[1] );
	p += 4;
	n = get32 (p);
	p += 4;
	fprintf (fp, "Recheck-After: %lu\n", n );
	n = get32 (p );
	p += 4;
	fprintf( fp, "Latest-Timestamp: %lu\n", n );
	n = get32 (p );
	p += 4;
	fprintf (fp, "Created-At: %lu\n", n );
	n = get32 (p );
	fprintf (fp, "Reserved-Space: %lu\n", n );

	if (n >= 4 && unhashed >= 24)
	{
	n = get32 ( buffer + length - unhashed);
	fprintf (fp, "Storage-Flags: %08lx\n", n );
	}
	- if (have_ubib)
	- print_ubib (buffer, length, fp);
	print_checksum (buffer, length, unhashed, fp);
	return 0;
	}


	/* Compute the SHA-1 checksum of the rawdata in BLOB and put it into
	DIGEST. */
	static int
	hash_blob_rawdata (KEYBOXBLOB blob, unsigned char *digest)
	{
	const unsigned char *buffer;
	size_t n, length;
	int type;
	ulong rawdata_off, rawdata_len;

	buffer = _keybox_get_blob_image (blob, &length);

	if (length < 32)
	return -1;
	n = get32 (buffer);
	if (n < length)
	length = n; /* Blob larger than length in header - ignore the rest. */

	type = buffer[4];
	switch (type)
	{
	case KEYBOX_BLOBTYPE_PGP:
	case KEYBOX_BLOBTYPE_X509:
	break;

	case KEYBOX_BLOBTYPE_EMPTY:
	case KEYBOX_BLOBTYPE_HEADER:
	default:
	memset (digest, 0, 20);
	return 0;
	}

	if (length < 40)
	return -1;

	rawdata_off = get32 (buffer + 8);
	rawdata_len = get32 (buffer + 12);

	if (rawdata_off > length \|\| rawdata_len > length
	\|\| rawdata_off+rawdata_off > length)
	return -1; /* Out of bounds. */

	gcry_md_hash_buffer (GCRY_MD_SHA1, digest, buffer+rawdata_off, rawdata_len);
	return 0;
	}


	struct file_stats_s
	{
	unsigned long too_short_blobs;
	unsigned long too_large_blobs;
	unsigned long total_blob_count;
	unsigned long empty_blob_count;
	unsigned long header_blob_count;
	unsigned long pgp_blob_count;
	unsigned long x509_blob_count;
	unsigned long unknown_blob_count;
	unsigned long non_flagged;
	unsigned long secret_flagged;
	unsigned long ephemeral_flagged;
	unsigned long skipped_long_blobs;
	};

	static int
	update_stats (KEYBOXBLOB blob, struct file_stats_s *s)
	{
	const unsigned char *buffer;
	size_t length;
	int type;
	unsigned long n;

	buffer = _keybox_get_blob_image (blob, &length);
	if (length < 32)
	{
	s->too_short_blobs++;
	return -1;
	}

	n = get32( buffer );
	if (n > length)
	s->too_large_blobs++;
	else
	length = n; /* ignore the rest */

	s->total_blob_count++;
	type = buffer[4];
	switch (type)
	{
	case KEYBOX_BLOBTYPE_EMPTY:
	s->empty_blob_count++;
	return 0;
	case KEYBOX_BLOBTYPE_HEADER:
	s->header_blob_count++;
	return 0;
	case KEYBOX_BLOBTYPE_PGP:
	s->pgp_blob_count++;
	break;
	case KEYBOX_BLOBTYPE_X509:
	s->x509_blob_count++;
	break;
	default:
	s->unknown_blob_count++;
	return 0;
	}

	if (length < 40)
	{
	s->too_short_blobs++;
	return -1;
	}

	n = get16 (buffer + 6);
	if (n)
	{
	if ((n & 1))
	s->secret_flagged++;
	if ((n & 2))
	s->ephemeral_flagged++;
	}
	else
	s->non_flagged++;

	return 0;
	}



	static FILE *
	open_file (const char *filename, FILE outfp)
	{
	FILE *fp;

	if (!*filename)
	{
	*filename = "-";
	fp = stdin;
	}
	else
	fp = fopen (*filename, "rb");
	if (!fp)
	{
	int save_errno = errno;
	fprintf (outfp, "can't open '%s': %s\n", *filename, strerror(errno));
	gpg_err_set_errno (save_errno);
	}
	return fp;
	}



	int
	_keybox_dump_file (const char filename, int stats_only, FILE outfp)
	{
	FILE *fp;
	KEYBOXBLOB blob;
	int rc;
	unsigned long count = 0;
	struct file_stats_s stats;
	int skipped_deleted;

	memset (&stats, 0, sizeof stats);

	if (!(fp = open_file (&filename, outfp)))
	return gpg_error_from_syserror ();

	for (;;)
	{
	rc = _keybox_read_blob (&blob, fp, &skipped_deleted);
	if (gpg_err_code (rc) == GPG_ERR_TOO_LARGE
	&& gpg_err_source (rc) == GPG_ERR_SOURCE_KEYBOX)
	{
	if (stats_only)
	stats.skipped_long_blobs++;
	else
	{
	fprintf (outfp, "BEGIN-RECORD: %lu\n", count );
	fprintf (outfp, "# Record too large\nEND-RECORD\n");
	}
	count++;
	continue;
	}
	if (rc)
	break;

	count += skipped_deleted;

	if (stats_only)
	{
	stats.total_blob_count += skipped_deleted;
	stats.empty_blob_count += skipped_deleted;
	update_stats (blob, &stats);
	}
	else
	{
	fprintf (outfp, "BEGIN-RECORD: %lu\n", count );
	_keybox_dump_blob (blob, outfp);
	fprintf (outfp, "END-RECORD\n");
	}
	_keybox_release_blob (blob);
	count++;
	}
	if (rc == -1)
	rc = 0;
	if (rc)
	fprintf (outfp, "# error reading '%s': %s\n", filename, gpg_strerror (rc));

	if (fp != stdin)
	fclose (fp);

	if (stats_only)
	{
	fprintf (outfp,
	"Total number of blobs: %8lu\n"
	" header: %8lu\n"
	" empty: %8lu\n"
	" openpgp: %8lu\n"
	" x509: %8lu\n"
	" non flagged: %8lu\n"
	" secret flagged: %8lu\n"
	" ephemeral flagged: %8lu\n",
	stats.total_blob_count,
	stats.header_blob_count,
	stats.empty_blob_count,
	stats.pgp_blob_count,
	stats.x509_blob_count,
	stats.non_flagged,
	stats.secret_flagged,
	stats.ephemeral_flagged);
	if (stats.skipped_long_blobs)
	fprintf (outfp, " skipped long blobs: %8lu\n",
	stats.skipped_long_blobs);
	if (stats.unknown_blob_count)
	fprintf (outfp, " unknown blob types: %8lu\n",
	stats.unknown_blob_count);
	if (stats.too_short_blobs)
	fprintf (outfp, " too short blobs: %8lu (error)\n",
	stats.too_short_blobs);
	if (stats.too_large_blobs)
	fprintf (outfp, " too large blobs: %8lu (error)\n",
	stats.too_large_blobs);
	}

	return rc;
	}



	struct dupitem_s
	{
	unsigned long recno;
	unsigned char digest[20];
	};


	static int
	cmp_dupitems (const void arg_a, const void arg_b)
	{
	struct dupitem_s a = (struct dupitem_s )arg_a;
	struct dupitem_s b = (struct dupitem_s )arg_b;

	return memcmp (a->digest, b->digest, 20);
	}


	int
	_keybox_dump_find_dups (const char filename, int print_them, FILE outfp)
	{
	FILE *fp;
	KEYBOXBLOB blob;
	int rc;
	unsigned long recno = 0;
	unsigned char zerodigest[20];
	struct dupitem_s *dupitems;
	size_t dupitems_size, dupitems_count, lastn, n;
	char fprbuf[3*20+1];

	(void)print_them;

	memset (zerodigest, 0, sizeof zerodigest);

	if (!(fp = open_file (&filename, outfp)))
	return gpg_error_from_syserror ();

	dupitems_size = 1000;
	dupitems = malloc (dupitems_size * sizeof *dupitems);
	if (!dupitems)
	{
	gpg_error_t tmperr = gpg_error_from_syserror ();
	fprintf (outfp, "error allocating array for '%s': %s\n",
	filename, strerror(errno));
	return tmperr;
	}
	dupitems_count = 0;

	while ( !(rc = _keybox_read_blob (&blob, fp, NULL)) )
	{
	unsigned char digest[20];

	if (hash_blob_rawdata (blob, digest))
	fprintf (outfp, "error in blob %ld of '%s'\n", recno, filename);
	else if (memcmp (digest, zerodigest, 20))
	{
	if (dupitems_count >= dupitems_size)
	{
	struct dupitem_s *tmp;

	dupitems_size += 1000;
	tmp = realloc (dupitems, dupitems_size * sizeof *dupitems);
	if (!tmp)
	{
	gpg_error_t tmperr = gpg_error_from_syserror ();
	fprintf (outfp, "error reallocating array for '%s': %s\n",
	filename, strerror(errno));
	free (dupitems);
	return tmperr;
	}
	dupitems = tmp;
	}
	dupitems[dupitems_count].recno = recno;
	memcpy (dupitems[dupitems_count].digest, digest, 20);
	dupitems_count++;
	}
	_keybox_release_blob (blob);
	recno++;
	}
	if (rc == -1)
	rc = 0;
	if (rc)
	fprintf (outfp, "error reading '%s': %s\n", filename, gpg_strerror (rc));
	if (fp != stdin)
	fclose (fp);

	qsort (dupitems, dupitems_count, sizeof *dupitems, cmp_dupitems);

	for (lastn=0, n=1; n < dupitems_count; lastn=n, n++)
	{
	if (!memcmp (dupitems[lastn].digest, dupitems[n].digest, 20))
	{
	bin2hexcolon (dupitems[lastn].digest, 20, fprbuf);
	fprintf (outfp, "fpr=%s recno=%lu", fprbuf, dupitems[lastn].recno);
	do
	fprintf (outfp, " %lu", dupitems[n].recno);
	while (++n < dupitems_count
	&& !memcmp (dupitems[lastn].digest, dupitems[n].digest, 20));
	putc ('\n', outfp);
	n--;
	}
	}

	free (dupitems);

	return rc;
	}


	/* Print records with record numbers FROM to TO to OUTFP. */
	int
	_keybox_dump_cut_records (const char *filename, unsigned long from,
	unsigned long to, FILE *outfp)
	{
	FILE *fp;
	KEYBOXBLOB blob;
	int rc;
	unsigned long recno = 0;

	if (!(fp = open_file (&filename, stderr)))
	return gpg_error_from_syserror ();

	while ( !(rc = _keybox_read_blob (&blob, fp, NULL)) )
	{
	if (recno > to)
	break; /* Ready. */
	if (recno >= from)
	{
	if ((rc = _keybox_write_blob (blob, outfp)))
	{
	fprintf (stderr, "error writing output: %s\n",
	gpg_strerror (rc));
	goto leave;
	}
	}
	_keybox_release_blob (blob);
	recno++;
	}
	if (rc == -1)
	rc = 0;
	if (rc)
	fprintf (stderr, "error reading '%s': %s\n", filename, gpg_strerror (rc));
	leave:
	if (fp != stdin)
	fclose (fp);
	return rc;
	}
	diff --git a/kbx/keybox-search-desc.h b/kbx/keybox-search-desc.h
	index 7fa97e97b..1167b1a6d 100644
	--- a/kbx/keybox-search-desc.h
	+++ b/kbx/keybox-search-desc.h
	@@ -1,96 +1,97 @@
	/* keybox-search-desc.h - Keybox serch description
	* Copyright (C) 2001 Free Software Foundation, Inc.
	*
	* 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/>.
	*/

	/*
	This file is a temporary kludge until we can come up with solution
	to share this description between keybox and the application
	specific keydb
	*/

	#ifndef KEYBOX_SEARCH_DESC_H
	#define KEYBOX_SEARCH_DESC_H 1

	typedef enum {
	KEYDB_SEARCH_MODE_NONE,
	KEYDB_SEARCH_MODE_EXACT,
	KEYDB_SEARCH_MODE_SUBSTR,
	KEYDB_SEARCH_MODE_MAIL,
	KEYDB_SEARCH_MODE_MAILSUB,
	KEYDB_SEARCH_MODE_MAILEND,
	KEYDB_SEARCH_MODE_WORDS,
	KEYDB_SEARCH_MODE_SHORT_KID,
	KEYDB_SEARCH_MODE_LONG_KID,
	KEYDB_SEARCH_MODE_FPR, /* (Length of fpr in .fprlen) */
	KEYDB_SEARCH_MODE_ISSUER,
	KEYDB_SEARCH_MODE_ISSUER_SN,
	KEYDB_SEARCH_MODE_SN,
	KEYDB_SEARCH_MODE_SUBJECT,
	KEYDB_SEARCH_MODE_KEYGRIP,
	KEYDB_SEARCH_MODE_UBID,
	KEYDB_SEARCH_MODE_FIRST,
	KEYDB_SEARCH_MODE_NEXT
	} KeydbSearchMode;


	/* Identifiers for the public key types we use in GnuPG. */
	enum pubkey_types
	{
	PUBKEY_TYPE_UNKNOWN = 0,
	PUBKEY_TYPE_OPGP = 1,
	PUBKEY_TYPE_X509 = 2
	};


	/* Forward declaration. See g10/packet.h. */
	struct gpg_pkt_user_id_s;
	typedef struct gpg_pkt_user_id_s *gpg_pkt_user_id_t;

	+
	/* A search descriptor. */
	struct keydb_search_desc
	{
	KeydbSearchMode mode;
	/* Callback used to filter results. The first parameter is
	SKIPFUNCVALUE. The second is the keyid. The third is the
	1-based index of the UID packet that matched the search criteria
	(or 0, if none).

	Return non-zero if the result should be skipped. */
	int (skipfnc)(void , u32 *, int);
	void *skipfncvalue;
	const unsigned char *sn;
	int snlen; /* -1 := sn is a hex string */
	union {
	const char *name;
	unsigned char fpr[32];
	u32 kid[2]; /* Note that this is in native endianness. */
	- unsigned char grip[20];
	- unsigned char ubid[20];
	+ unsigned char grip[KEYGRIP_LEN];
	+ unsigned char ubid[UBID_LEN];
	} u;
	byte fprlen; /* Only used with KEYDB_SEARCH_MODE_FPR. */
	int exact; /* Use exactly this key ('!' suffix in gpg). */
	};


	struct keydb_search_desc;
	typedef struct keydb_search_desc KEYDB_SEARCH_DESC;
	typedef struct keydb_search_desc KEYBOX_SEARCH_DESC;



	#endif /KEYBOX_SEARCH_DESC_H/
	diff --git a/kbx/keybox-search.c b/kbx/keybox-search.c
	index 95ad07251..91d2a1735 100644
	--- a/kbx/keybox-search.c
	+++ b/kbx/keybox-search.c
	@@ -1,1439 +1,1464 @@
	/* keybox-search.c - Search operations
	* Copyright (C) 2001, 2002, 2003, 2004, 2012,
	* 2013 Free Software Foundation, Inc.
	*
	* 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 <stdlib.h>
	#include <stdio.h>
	#include <string.h>
	#include <assert.h>
	#include <errno.h>

	#include "keybox-defs.h"
	#include <gcrypt.h>
	#include "../common/host2net.h"
	#include "../common/mbox-util.h"

	#define xtoi_1(p) ((p) <= '9'? ((p)- '0'): \
	(p) <= 'F'? ((p)-'A'+10):(*(p)-'a'+10))
	#define xtoi_2(p) ((xtoi_1(p) * 16) + xtoi_1((p)+1))


	struct sn_array_s {
	int snlen;
	unsigned char *sn;
	};


	#define get32(a) buf32_to_ulong ((a))
	#define get16(a) buf16_to_ulong ((a))


	static inline unsigned int
	blob_get_blob_flags (KEYBOXBLOB blob)
	{
	const unsigned char *buffer;
	size_t length;

	buffer = _keybox_get_blob_image (blob, &length);
	if (length < 8)
	return 0; /* oops */

	return get16 (buffer + 6);
	}


	/* Return the first keyid from the blob. Returns true if
	available. */
	static int
	blob_get_first_keyid (KEYBOXBLOB blob, u32 *kid)
	{
	const unsigned char *buffer;
	size_t length, nkeys, keyinfolen;
	int fpr32;

	buffer = _keybox_get_blob_image (blob, &length);
	if (length < 48)
	return 0; /* blob too short */
	fpr32 = buffer[5] == 2;
	if (fpr32 && length < 56)
	return 0; /* blob to short */

	nkeys = get16 (buffer + 16);
	keyinfolen = get16 (buffer + 18);
	if (!nkeys \|\| keyinfolen < (fpr32?56:28))
	return 0; /* invalid blob */

	if (fpr32 && (get16 (buffer + 20 + 32) & 0x80))
	{
	/* 32 byte fingerprint. */
	kid[0] = get32 (buffer + 20);
	kid[1] = get32 (buffer + 20 + 4);
	}
	else /* 20 byte fingerprint. */
	{
	kid[0] = get32 (buffer + 20 + 12);
	kid[1] = get32 (buffer + 20 + 16);
	}

	return 1;
	}


	/* Return information on the flag WHAT within the blob BUFFER,LENGTH.
	Return the offset and the length (in bytes) of the flag in
	FLAGOFF,FLAG_SIZE. */
	gpg_err_code_t
	_keybox_get_flag_location (const unsigned char *buffer, size_t length,
	int what, size_t flag_off, size_t flag_size)
	{
	size_t pos;
	size_t nkeys, keyinfolen;
	size_t nuids, uidinfolen;
	size_t nserial;
	size_t nsigs, siginfolen, siginfooff;

	switch (what)
	{
	case KEYBOX_FLAG_BLOB:
	if (length < 8)
	return GPG_ERR_INV_OBJ;
	*flag_off = 6;
	*flag_size = 2;
	break;

	case KEYBOX_FLAG_OWNERTRUST:
	case KEYBOX_FLAG_VALIDITY:
	case KEYBOX_FLAG_CREATED_AT:
	case KEYBOX_FLAG_SIG_INFO:
	if (length < 20)
	return GPG_ERR_INV_OBJ;
	/* Key info. */
	nkeys = get16 (buffer + 16);
	keyinfolen = get16 (buffer + 18 );
	if (keyinfolen < 28)
	return GPG_ERR_INV_OBJ;
	pos = 20 + keyinfolen*nkeys;
	if (pos+2 > length)
	return GPG_ERR_INV_OBJ; /* Out of bounds. */
	/* Serial number. */
	nserial = get16 (buffer+pos);
	pos += 2 + nserial;
	if (pos+4 > length)
	return GPG_ERR_INV_OBJ; /* Out of bounds. */
	/* User IDs. */
	nuids = get16 (buffer + pos); pos += 2;
	uidinfolen = get16 (buffer + pos); pos += 2;
	if (uidinfolen < 12 )
	return GPG_ERR_INV_OBJ;
	pos += uidinfolen*nuids;
	if (pos+4 > length)
	return GPG_ERR_INV_OBJ ; /* Out of bounds. */
	/* Signature info. */
	siginfooff = pos;
	nsigs = get16 (buffer + pos); pos += 2;
	siginfolen = get16 (buffer + pos); pos += 2;
	if (siginfolen < 4 )
	return GPG_ERR_INV_OBJ;
	pos += siginfolen*nsigs;
	if (pos+1+1+2+4+4+4+4 > length)
	return GPG_ERR_INV_OBJ ; /* Out of bounds. */
	*flag_size = 1;
	*flag_off = pos;
	switch (what)
	{
	case KEYBOX_FLAG_VALIDITY:
	*flag_off += 1;
	break;
	case KEYBOX_FLAG_CREATED_AT:
	*flag_size = 4;
	*flag_off += 1+2+4+4+4;
	break;
	case KEYBOX_FLAG_SIG_INFO:
	flag_size = siginfolen nsigs;
	*flag_off = siginfooff;
	break;
	default:
	break;
	}
	break;

	default:
	return GPG_ERR_INV_FLAG;
	}
	return 0;
	}



	/* Return one of the flags WHAT in VALUE from the blob BUFFER of
	LENGTH bytes. Return 0 on success or an raw error code. */
	static gpg_err_code_t
	get_flag_from_image (const unsigned char *buffer, size_t length,
	int what, unsigned int *value)
	{
	gpg_err_code_t ec;
	size_t pos, size;

	*value = 0;
	ec = _keybox_get_flag_location (buffer, length, what, &pos, &size);
	if (!ec)
	switch (size)
	{
	case 1: *value = buffer[pos]; break;
	case 2: *value = get16 (buffer + pos); break;
	case 4: *value = get32 (buffer + pos); break;
	default: ec = GPG_ERR_BUG; break;
	}

	return ec;
	}


	static int
	blob_cmp_sn (KEYBOXBLOB blob, const unsigned char *sn, int snlen)
	{
	const unsigned char *buffer;
	size_t length;
	size_t pos, off;
	size_t nkeys, keyinfolen;
	size_t nserial;

	buffer = _keybox_get_blob_image (blob, &length);
	if (length < 40)
	return 0; /* blob too short */

	/keys/
	nkeys = get16 (buffer + 16);
	keyinfolen = get16 (buffer + 18 );
	if (keyinfolen < 28)
	return 0; /* invalid blob */
	pos = 20 + keyinfolen*nkeys;
	if (pos+2 > length)
	return 0; /* out of bounds */

	/serial/
	nserial = get16 (buffer+pos);
	off = pos + 2;
	if (off+nserial > length)
	return 0; /* out of bounds */

	return nserial == snlen && !memcmp (buffer+off, sn, snlen);
	}


	/* Returns 0 if not found or the number of the key which was found.
	For X.509 this is always 1, for OpenPGP this is 1 for the primary
	key and 2 and more for the subkeys. */
	static int
	blob_cmp_fpr (KEYBOXBLOB blob, const unsigned char *fpr, unsigned int fprlen)
	{
	const unsigned char *buffer;
	size_t length;
	size_t pos, off;
	size_t nkeys, keyinfolen;
	int idx, fpr32, storedfprlen;

	buffer = _keybox_get_blob_image (blob, &length);
	if (length < 40)
	return 0; /* blob too short */
	fpr32 = buffer[5] == 2;

	/keys/
	nkeys = get16 (buffer + 16);
	keyinfolen = get16 (buffer + 18 );
	if (keyinfolen < (fpr32?56:28))
	return 0; /* invalid blob */
	pos = 20;
	if (pos + (uint64_t)keyinfolen*nkeys > (uint64_t)length)
	return 0; /* out of bounds */

	for (idx=0; idx < nkeys; idx++)
	{
	off = pos + idx*keyinfolen;
	if (fpr32)
	storedfprlen = (get16 (buffer + off + 32) & 0x80)? 32:20;
	else
	storedfprlen = 20;
	if (storedfprlen == fprlen
	&& !memcmp (buffer + off, fpr, storedfprlen))
	return idx+1; /* found */
	}
	return 0; /* not found */
	}


	/* Helper for has_short_kid and has_long_kid. */
	static int
	blob_cmp_fpr_part (KEYBOXBLOB blob, const unsigned char *fpr,
	int fproff, int fprlen)
	{
	const unsigned char *buffer;
	size_t length;
	size_t pos, off;
	size_t nkeys, keyinfolen;
	int idx, fpr32, storedfprlen;

	buffer = _keybox_get_blob_image (blob, &length);
	if (length < 40)
	return 0; /* blob too short */
	fpr32 = buffer[5] == 2;

	/keys/
	nkeys = get16 (buffer + 16);
	keyinfolen = get16 (buffer + 18 );
	if (keyinfolen < (fpr32?56:28))
	return 0; /* invalid blob */
	pos = 20;
	if (pos + (uint64_t)keyinfolen*nkeys > (uint64_t)length)
	return 0; /* out of bounds */

	if (fpr32)
	fproff = 0; /* keyid are the high-order bits. */
	for (idx=0; idx < nkeys; idx++)
	{
	off = pos + idx*keyinfolen;
	if (fpr32)
	storedfprlen = (get16 (buffer + off + 32) & 0x80)? 32:20;
	else
	storedfprlen = 20;
	if (storedfprlen == fproff + fprlen
	&& !memcmp (buffer + off + fproff, fpr, fprlen))
	return idx+1; /* found */
	}
	return 0; /* not found */
	}


	+/* Returns true if found. */
	+static int
	+blob_cmp_ubid (KEYBOXBLOB blob, const unsigned char *ubid)
	+{
	+ const unsigned char *buffer;
	+ size_t length;
	+ size_t pos;
	+ size_t nkeys, keyinfolen;
	+ int fpr32;
	+
	+ buffer = _keybox_get_blob_image (blob, &length);
	+ if (length < 40)
	+ return 0; /* blob too short */
	+ fpr32 = buffer[5] == 2;
	+
	+ /keys/
	+ nkeys = get16 (buffer + 16);
	+ keyinfolen = get16 (buffer + 18 );
	+ if (!nkeys \|\| keyinfolen < (fpr32?56:28))
	+ return 0; /* invalid blob */
	+ pos = 20;
	+ if (pos + (uint64_t)keyinfolen*nkeys > (uint64_t)length)
	+ return 0; /* out of bounds */
	+
	+ if (!memcmp (buffer + pos, ubid, UBID_LEN))
	+ return 1; /* found */
	+ return 0; /* not found */
	+}
	+
	+
	static int
	blob_cmp_name (KEYBOXBLOB blob, int idx,
	const char *name, size_t namelen, int substr, int x509)
	{
	const unsigned char *buffer;
	size_t length;
	size_t pos, off, len;
	size_t nkeys, keyinfolen;
	size_t nuids, uidinfolen;
	size_t nserial;

	buffer = _keybox_get_blob_image (blob, &length);
	if (length < 40)
	return 0; /* blob too short */

	/keys/
	nkeys = get16 (buffer + 16);
	keyinfolen = get16 (buffer + 18 );
	if (keyinfolen < 28)
	return 0; /* invalid blob */
	pos = 20 + keyinfolen*nkeys;
	if ((uint64_t)pos+2 > (uint64_t)length)
	return 0; /* out of bounds */

	/serial/
	nserial = get16 (buffer+pos);
	pos += 2 + nserial;
	if (pos+4 > length)
	return 0; /* out of bounds */

	/* user ids*/
	nuids = get16 (buffer + pos); pos += 2;
	uidinfolen = get16 (buffer + pos); pos += 2;
	if (uidinfolen < 12 /* should add a: \|\| nuidinfolen > MAX_UIDINFOLEN */)
	return 0; /* invalid blob */
	if (pos + uidinfolen*nuids > length)
	return 0; /* out of bounds */

	if (idx < 0)
	{ /* Compare all names. Note that for X.509 we start with index 1
	so to skip the issuer at index 0. */
	for (idx = !!x509; idx < nuids; idx++)
	{
	size_t mypos = pos;

	mypos += idx*uidinfolen;
	off = get32 (buffer+mypos);
	len = get32 (buffer+mypos+4);
	if ((uint64_t)off+(uint64_t)len > (uint64_t)length)
	return 0; /* error: better stop here out of bounds */
	if (len < 1)
	continue; /* empty name */
	if (substr)
	{
	if (ascii_memcasemem (buffer+off, len, name, namelen))
	return idx+1; /* found */
	}
	else
	{
	if (len == namelen && !memcmp (buffer+off, name, len))
	return idx+1; /* found */
	}
	}
	}
	else
	{
	if (idx > nuids)
	return 0; /* no user ID with that idx */
	pos += idx*uidinfolen;
	off = get32 (buffer+pos);
	len = get32 (buffer+pos+4);
	if (off+len > length)
	return 0; /* out of bounds */
	if (len < 1)
	return 0; /* empty name */

	if (substr)
	{
	if (ascii_memcasemem (buffer+off, len, name, namelen))
	return idx+1; /* found */
	}
	else
	{
	if (len == namelen && !memcmp (buffer+off, name, len))
	return idx+1; /* found */
	}
	}
	return 0; /* not found */
	}


	/* Compare all email addresses of the subject. With SUBSTR given as
	True a substring search is done in the mail address. The X509 flag
	indicated whether the search is done on an X.509 blob. */
	static int
	blob_cmp_mail (KEYBOXBLOB blob, const char *name, size_t namelen, int substr,
	int x509)
	{
	const unsigned char *buffer;
	size_t length;
	size_t pos, off, len;
	size_t nkeys, keyinfolen;
	size_t nuids, uidinfolen;
	size_t nserial;
	int idx;

	/* fixme: this code is common to blob_cmp_mail */
	buffer = _keybox_get_blob_image (blob, &length);
	if (length < 40)
	return 0; /* blob too short */

	/keys/
	nkeys = get16 (buffer + 16);
	keyinfolen = get16 (buffer + 18 );
	if (keyinfolen < 28)
	return 0; /* invalid blob */
	pos = 20 + keyinfolen*nkeys;
	if (pos+2 > length)
	return 0; /* out of bounds */

	/serial/
	nserial = get16 (buffer+pos);
	pos += 2 + nserial;
	if (pos+4 > length)
	return 0; /* out of bounds */

	/* user ids*/
	nuids = get16 (buffer + pos); pos += 2;
	uidinfolen = get16 (buffer + pos); pos += 2;
	if (uidinfolen < 12 /* should add a: \|\| nuidinfolen > MAX_UIDINFOLEN */)
	return 0; /* invalid blob */
	if (pos + uidinfolen*nuids > length)
	return 0; /* out of bounds */

	if (namelen < 1)
	return 0;

	/* Note that for X.509 we start at index 1 because index 0 is used
	for the issuer name. */
	for (idx=!!x509 ;idx < nuids; idx++)
	{
	size_t mypos = pos;
	size_t mylen;

	mypos += idx*uidinfolen;
	off = get32 (buffer+mypos);
	len = get32 (buffer+mypos+4);
	if ((uint64_t)off+(uint64_t)len > (uint64_t)length)
	return 0; /* error: better stop here - out of bounds */
	if (x509)
	{
	if (len < 2 \|\| buffer[off] != '<')
	continue; /* empty name or trailing 0 not stored */
	len--; /* one back */
	if ( len < 3 \|\| buffer[off+len] != '>')
	continue; /* not a proper email address */
	off++;
	len--;
	}
	else /* OpenPGP. */
	{
	/* We need to forward to the mailbox part. */
	mypos = off;
	mylen = len;
	for ( ; len && buffer[off] != '<'; len--, off++)
	;
	if (len < 2 \|\| buffer[off] != '<')
	{
	/* Mailbox not explicitly given or too short. Restore
	OFF and LEN and check whether the entire string
	resembles a mailbox without the angle brackets. */
	off = mypos;
	len = mylen;
	if (!is_valid_mailbox_mem (buffer+off, len))
	continue; /* Not a mail address. */
	}
	else /* Seems to be standard user id with mail address. */
	{
	off++; /* Point to first char of the mail address. */
	len--;
	/* Search closing '>'. */
	for (mypos=off; len && buffer[mypos] != '>'; len--, mypos++)
	;
	if (!len \|\| buffer[mypos] != '>' \|\| off == mypos)
	continue; /* Not a proper mail address. */
	len = mypos - off;
	}

	}

	if (substr)
	{
	if (ascii_memcasemem (buffer+off, len, name, namelen))
	return idx+1; /* found */
	}
	else
	{
	if (len == namelen && !ascii_memcasecmp (buffer+off, name, len))
	return idx+1; /* found */
	}
	}
	return 0; /* not found */
	}


	/* Return true if the key in BLOB matches the 20 bytes keygrip GRIP.
	* We don't have the keygrips as meta data, thus we need to parse the
	* certificate. Fixme: We might want to return proper error codes
	* instead of failing a search for invalid certificates etc. */
	static int
	blob_openpgp_has_grip (KEYBOXBLOB blob, const unsigned char *grip)
	{
	int rc = 0;
	const unsigned char *buffer;
	size_t length;
	size_t cert_off, cert_len;
	struct _keybox_openpgp_info info;
	struct _keybox_openpgp_key_info *k;

	buffer = _keybox_get_blob_image (blob, &length);
	if (length < 40)
	return 0; /* Too short. */
	cert_off = get32 (buffer+8);
	cert_len = get32 (buffer+12);
	if ((uint64_t)cert_off+(uint64_t)cert_len > (uint64_t)length)
	return 0; /* Too short. */

	if (_keybox_parse_openpgp (buffer + cert_off, cert_len, NULL, &info))
	return 0; /* Parse error. */

	if (!memcmp (info.primary.grip, grip, 20))
	{
	rc = 1;
	goto leave;
	}

	if (info.nsubkeys)
	{
	k = &info.subkeys;
	do
	{
	if (!memcmp (k->grip, grip, 20))
	{
	rc = 1;
	goto leave;
	}
	k = k->next;
	}
	while (k);
	}

	leave:
	_keybox_destroy_openpgp_info (&info);
	return rc;
	}


	#ifdef KEYBOX_WITH_X509
	/* Return true if the key in BLOB matches the 20 bytes keygrip GRIP.
	We don't have the keygrips as meta data, thus we need to parse the
	certificate. Fixme: We might want to return proper error codes
	instead of failing a search for invalid certificates etc. */
	static int
	blob_x509_has_grip (KEYBOXBLOB blob, const unsigned char *grip)
	{
	int rc;
	const unsigned char *buffer;
	size_t length;
	size_t cert_off, cert_len;
	ksba_reader_t reader = NULL;
	ksba_cert_t cert = NULL;
	ksba_sexp_t p = NULL;
	gcry_sexp_t s_pkey;
	unsigned char array[20];
	unsigned char *rcp;
	size_t n;

	buffer = _keybox_get_blob_image (blob, &length);
	if (length < 40)
	return 0; /* Too short. */
	cert_off = get32 (buffer+8);
	cert_len = get32 (buffer+12);
	if ((uint64_t)cert_off+(uint64_t)cert_len > (uint64_t)length)
	return 0; /* Too short. */

	rc = ksba_reader_new (&reader);
	if (rc)
	return 0; /* Problem with ksba. */
	rc = ksba_reader_set_mem (reader, buffer+cert_off, cert_len);
	if (rc)
	goto failed;
	rc = ksba_cert_new (&cert);
	if (rc)
	goto failed;
	rc = ksba_cert_read_der (cert, reader);
	if (rc)
	goto failed;
	p = ksba_cert_get_public_key (cert);
	if (!p)
	goto failed;
	n = gcry_sexp_canon_len (p, 0, NULL, NULL);
	if (!n)
	goto failed;
	rc = gcry_sexp_sscan (&s_pkey, NULL, (char*)p, n);
	if (rc)
	{
	gcry_sexp_release (s_pkey);
	goto failed;
	}
	rcp = gcry_pk_get_keygrip (s_pkey, array);
	gcry_sexp_release (s_pkey);
	if (!rcp)
	goto failed; /* Can't calculate keygrip. */

	xfree (p);
	ksba_cert_release (cert);
	ksba_reader_release (reader);
	return !memcmp (array, grip, 20);
	failed:
	xfree (p);
	ksba_cert_release (cert);
	ksba_reader_release (reader);
	return 0;
	}
	#endif /KEYBOX_WITH_X509/



	/*
	The has_foo functions are used as helpers for search
	*/
	static inline int
	has_short_kid (KEYBOXBLOB blob, u32 lkid)
	{
	unsigned char buf[4];
	buf[0] = lkid >> 24;
	buf[1] = lkid >> 16;
	buf[2] = lkid >> 8;
	buf[3] = lkid;
	return blob_cmp_fpr_part (blob, buf, 16, 4);
	}

	static inline int
	has_long_kid (KEYBOXBLOB blob, u32 mkid, u32 lkid)
	{
	unsigned char buf[8];
	buf[0] = mkid >> 24;
	buf[1] = mkid >> 16;
	buf[2] = mkid >> 8;
	buf[3] = mkid;
	buf[4] = lkid >> 24;
	buf[5] = lkid >> 16;
	buf[6] = lkid >> 8;
	buf[7] = lkid;
	return blob_cmp_fpr_part (blob, buf, 12, 8);
	}

	static inline int
	has_fingerprint (KEYBOXBLOB blob, const unsigned char *fpr, unsigned int fprlen)
	{
	return blob_cmp_fpr (blob, fpr, fprlen);
	}

	static inline int
	has_keygrip (KEYBOXBLOB blob, const unsigned char *grip)
	{
	if (blob_get_type (blob) == KEYBOX_BLOBTYPE_PGP)
	return blob_openpgp_has_grip (blob, grip);
	#ifdef KEYBOX_WITH_X509
	if (blob_get_type (blob) == KEYBOX_BLOBTYPE_X509)
	return blob_x509_has_grip (blob, grip);
	#endif
	return 0;
	}

	+
	+/* The UBID is the primary fingerprint. For OpenPGP v5 keys only the
	+ * leftmost 20 bytes (UBID_LEN) are used. */
	static inline int
	has_ubid (KEYBOXBLOB blob, const unsigned char *ubid)
	{
	- size_t length;
	- const unsigned char *buffer;
	- size_t image_off, image_len;
	- unsigned char ubid_blob[20];
	-
	- buffer = _keybox_get_blob_image (blob, &length);
	- if (length < 40)
	- return 0; /GPG_ERR_TOO_SHORT/
	-
	- if ((get16 (buffer + 6) & 4))
	- {
	- /* The blob has a stored UBID. */
	- return !memcmp (ubid, buffer + length - 40, 20);
	- }
	- else
	- {
	- /* Need to compute the UBID. */
	- image_off = get32 (buffer+8);
	- image_len = get32 (buffer+12);
	- if ((uint64_t)image_off+(uint64_t)image_len > (uint64_t)length)
	- return 0; /GPG_ERR_TOO_SHORT/
	-
	- gcry_md_hash_buffer (GCRY_MD_SHA1, ubid_blob, buffer+image_off,image_len);
	- return !memcmp (ubid, ubid_blob, 20);
	- }
	+ return blob_cmp_ubid (blob, ubid);
	}

	+
	static inline int
	has_issuer (KEYBOXBLOB blob, const char *name)
	{
	size_t namelen;

	return_val_if_fail (name, 0);

	if (blob_get_type (blob) != KEYBOX_BLOBTYPE_X509)
	return 0;

	namelen = strlen (name);
	return blob_cmp_name (blob, 0 /* issuer */, name, namelen, 0, 1);
	}

	static inline int
	has_issuer_sn (KEYBOXBLOB blob, const char *name,
	const unsigned char *sn, int snlen)
	{
	size_t namelen;

	return_val_if_fail (name, 0);
	return_val_if_fail (sn, 0);

	if (blob_get_type (blob) != KEYBOX_BLOBTYPE_X509)
	return 0;

	namelen = strlen (name);

	return (blob_cmp_sn (blob, sn, snlen)
	&& blob_cmp_name (blob, 0 /* issuer */, name, namelen, 0, 1));
	}

	static inline int
	has_sn (KEYBOXBLOB blob, const unsigned char *sn, int snlen)
	{
	return_val_if_fail (sn, 0);

	if (blob_get_type (blob) != KEYBOX_BLOBTYPE_X509)
	return 0;
	return blob_cmp_sn (blob, sn, snlen);
	}

	static inline int
	has_subject (KEYBOXBLOB blob, const char *name)
	{
	size_t namelen;

	return_val_if_fail (name, 0);

	if (blob_get_type (blob) != KEYBOX_BLOBTYPE_X509)
	return 0;

	namelen = strlen (name);
	return blob_cmp_name (blob, 1 /* subject */, name, namelen, 0, 1);
	}


	static inline int
	has_username (KEYBOXBLOB blob, const char *name, int substr)
	{
	size_t namelen;
	int btype;

	return_val_if_fail (name, 0);

	btype = blob_get_type (blob);
	if (btype != KEYBOX_BLOBTYPE_PGP && btype != KEYBOX_BLOBTYPE_X509)
	return 0;

	namelen = strlen (name);
	return blob_cmp_name (blob, -1 /* all subject/user names */, name,
	namelen, substr, (btype == KEYBOX_BLOBTYPE_X509));
	}


	static inline int
	has_mail (KEYBOXBLOB blob, const char *name, int substr)
	{
	size_t namelen;
	int btype;

	return_val_if_fail (name, 0);

	btype = blob_get_type (blob);
	if (btype != KEYBOX_BLOBTYPE_PGP && btype != KEYBOX_BLOBTYPE_X509)
	return 0;

	if (btype == KEYBOX_BLOBTYPE_PGP && *name == '<')
	name++; /* Hack to remove the leading '<' for gpg. */

	namelen = strlen (name);
	if (namelen && name[namelen-1] == '>')
	namelen--;
	return blob_cmp_mail (blob, name, namelen, substr,
	(btype == KEYBOX_BLOBTYPE_X509));
	}


	static void
	release_sn_array (struct sn_array_s *array, size_t size)
	{
	size_t n;

	for (n=0; n < size; n++)
	xfree (array[n].sn);
	xfree (array);
	}


	/* Helper to open the file. */
	static gpg_error_t
	open_file (KEYBOX_HANDLE hd)
	{

	hd->fp = fopen (hd->kb->fname, "rb");
	if (!hd->fp)
	{
	hd->error = gpg_error_from_syserror ();
	return hd->error;
	}

	return 0;
	}



	/*

	The search API

	*/

	gpg_error_t
	keybox_search_reset (KEYBOX_HANDLE hd)
	{
	if (!hd)
	return gpg_error (GPG_ERR_INV_VALUE);

	if (hd->found.blob)
	{
	_keybox_release_blob (hd->found.blob);
	hd->found.blob = NULL;
	}

	if (hd->fp)
	{
	if (fseeko (hd->fp, 0, SEEK_SET))
	{
	/* Ooops. Seek did not work. Close so that the search will
	* open the file again. */
	fclose (hd->fp);
	hd->fp = NULL;
	}
	}
	hd->error = 0;
	hd->eof = 0;
	return 0;
	}


	/* Note: When in ephemeral mode the search function does visit all
	blobs but in standard mode, blobs flagged as ephemeral are ignored.
	If WANT_BLOBTYPE is not 0 only blobs of this type are considered.
	The value at R_SKIPPED is updated by the number of skipped long
	records (counts PGP and X.509). */
	gpg_error_t
	keybox_search (KEYBOX_HANDLE hd, KEYBOX_SEARCH_DESC *desc, size_t ndesc,
	keybox_blobtype_t want_blobtype,
	size_t r_descindex, unsigned long r_skipped)
	{
	gpg_error_t rc;
	size_t n;
	int need_words, any_skip;
	KEYBOXBLOB blob = NULL;
	struct sn_array_s *sn_array = NULL;
	int pk_no, uid_no;
	off_t lastfoundoff;

	if (!hd)
	return gpg_error (GPG_ERR_INV_VALUE);

	/* Clear last found result but reord the offset of the last found
	* blob which we may need later. */
	if (hd->found.blob)
	{
	lastfoundoff = _keybox_get_blob_fileoffset (hd->found.blob);
	_keybox_release_blob (hd->found.blob);
	hd->found.blob = NULL;
	}
	else
	lastfoundoff = 0;

	if (hd->error)
	return hd->error; /* still in error state */
	if (hd->eof)
	return -1; /* still EOF */

	/* figure out what information we need */
	need_words = any_skip = 0;
	for (n=0; n < ndesc; n++)
	{
	switch (desc[n].mode)
	{
	case KEYDB_SEARCH_MODE_WORDS:
	need_words = 1;
	break;
	case KEYDB_SEARCH_MODE_FIRST:
	/* always restart the search in this mode */
	keybox_search_reset (hd);
	lastfoundoff = 0;
	break;
	default:
	break;
	}
	if (desc[n].skipfnc)
	any_skip = 1;
	if (desc[n].snlen == -1 && !sn_array)
	{
	sn_array = xtrycalloc (ndesc, sizeof *sn_array);
	if (!sn_array)
	return (hd->error = gpg_error_from_syserror ());
	}
	}

	(void)need_words; /* Not yet implemented. */

	if (!hd->fp)
	{
	rc = open_file (hd);
	if (rc)
	{
	xfree (sn_array);
	return rc;
	}
	/* log_debug ("%s: re-opened file\n", __func__); */
	if (ndesc && desc[0].mode != KEYDB_SEARCH_MODE_FIRST && lastfoundoff)
	{
	/* Search mode is not first and the last search operation
	* returned a blob which also was not the first one. We now
	* need to skip over that blob and hope that the file has
	* not changed. */
	if (fseeko (hd->fp, lastfoundoff, SEEK_SET))
	{
	rc = gpg_error_from_syserror ();
	log_debug ("%s: seeking to last found offset failed: %s\n",
	__func__, gpg_strerror (rc));
	xfree (sn_array);
	return gpg_error (GPG_ERR_NOTHING_FOUND);
	}
	/* log_debug ("%s: re-opened file and sought to last offset\n", */
	/* __func__); */
	rc = _keybox_read_blob (NULL, hd->fp, NULL);
	if (rc)
	{
	log_debug ("%s: skipping last found blob failed: %s\n",
	__func__, gpg_strerror (rc));
	xfree (sn_array);
	return gpg_error (GPG_ERR_NOTHING_FOUND);
	}
	}
	}

	/* Kludge: We need to convert an SN given as hexstring to its binary
	representation - in some cases we are not able to store it in the
	search descriptor, because due to the way we use it, it is not
	possible to free allocated memory. */
	if (sn_array)
	{
	const unsigned char *s;
	int i, odd;
	size_t snlen;

	for (n=0; n < ndesc; n++)
	{
	if (!desc[n].sn)
	;
	else if (desc[n].snlen == -1)
	{
	unsigned char *sn;

	s = desc[n].sn;
	for (i=0; s && s != '/'; s++, i++)
	;
	odd = (i & 1);
	snlen = (i+1)/2;
	sn_array[n].sn = xtrymalloc (snlen);
	if (!sn_array[n].sn)
	{
	hd->error = gpg_error_from_syserror ();
	release_sn_array (sn_array, n);
	return hd->error;
	}
	sn_array[n].snlen = snlen;
	sn = sn_array[n].sn;
	s = desc[n].sn;
	if (odd)
	{
	*sn++ = xtoi_1 (s);
	s++;
	}
	for (; s && s != '/'; s += 2)
	*sn++ = xtoi_2 (s);
	}
	else
	{
	const unsigned char *sn;

	sn = desc[n].sn;
	snlen = desc[n].snlen;
	sn_array[n].sn = xtrymalloc (snlen);
	if (!sn_array[n].sn)
	{
	hd->error = gpg_error_from_syserror ();
	release_sn_array (sn_array, n);
	return hd->error;
	}
	sn_array[n].snlen = snlen;
	memcpy (sn_array[n].sn, sn, snlen);
	}
	}
	}


	pk_no = uid_no = 0;
	for (;;)
	{
	unsigned int blobflags;
	int blobtype;

	_keybox_release_blob (blob); blob = NULL;
	rc = _keybox_read_blob (&blob, hd->fp, NULL);
	if (gpg_err_code (rc) == GPG_ERR_TOO_LARGE
	&& gpg_err_source (rc) == GPG_ERR_SOURCE_KEYBOX)
	{
	++*r_skipped;
	continue; /* Skip too large records. */
	}

	if (rc)
	break;

	blobtype = blob_get_type (blob);
	if (blobtype == KEYBOX_BLOBTYPE_HEADER)
	continue;
	if (want_blobtype && blobtype != want_blobtype)
	continue;

	blobflags = blob_get_blob_flags (blob);
	if (!hd->ephemeral && (blobflags & 2))
	continue; /* Not in ephemeral mode but blob is flagged ephemeral. */

	for (n=0; n < ndesc; n++)
	{
	switch (desc[n].mode)
	{
	case KEYDB_SEARCH_MODE_NONE:
	never_reached ();
	break;
	case KEYDB_SEARCH_MODE_EXACT:
	uid_no = has_username (blob, desc[n].u.name, 0);
	if (uid_no)
	goto found;
	break;
	case KEYDB_SEARCH_MODE_MAIL:
	uid_no = has_mail (blob, desc[n].u.name, 0);
	if (uid_no)
	goto found;
	break;
	case KEYDB_SEARCH_MODE_MAILSUB:
	uid_no = has_mail (blob, desc[n].u.name, 1);
	if (uid_no)
	goto found;
	break;
	case KEYDB_SEARCH_MODE_SUBSTR:
	uid_no = has_username (blob, desc[n].u.name, 1);
	if (uid_no)
	goto found;
	break;
	case KEYDB_SEARCH_MODE_MAILEND:
	case KEYDB_SEARCH_MODE_WORDS:
	/* not yet implemented */
	break;
	case KEYDB_SEARCH_MODE_ISSUER:
	if (has_issuer (blob, desc[n].u.name))
	goto found;
	break;
	case KEYDB_SEARCH_MODE_ISSUER_SN:
	if (has_issuer_sn (blob, desc[n].u.name,
	sn_array? sn_array[n].sn : desc[n].sn,
	sn_array? sn_array[n].snlen : desc[n].snlen))
	goto found;
	break;
	case KEYDB_SEARCH_MODE_SN:
	if (has_sn (blob, sn_array? sn_array[n].sn : desc[n].sn,
	sn_array? sn_array[n].snlen : desc[n].snlen))
	goto found;
	break;
	case KEYDB_SEARCH_MODE_SUBJECT:
	if (has_subject (blob, desc[n].u.name))
	goto found;
	break;
	case KEYDB_SEARCH_MODE_SHORT_KID:
	pk_no = has_short_kid (blob, desc[n].u.kid[1]);
	if (pk_no)
	goto found;
	break;
	case KEYDB_SEARCH_MODE_LONG_KID:
	pk_no = has_long_kid (blob, desc[n].u.kid[0], desc[n].u.kid[1]);
	if (pk_no)
	goto found;
	break;

	case KEYDB_SEARCH_MODE_FPR:
	pk_no = has_fingerprint (blob, desc[n].u.fpr, desc[n].fprlen);
	if (pk_no)
	goto found;
	break;

	case KEYDB_SEARCH_MODE_KEYGRIP:
	if (has_keygrip (blob, desc[n].u.grip))
	goto found;
	break;
	case KEYDB_SEARCH_MODE_UBID:
	if (has_ubid (blob, desc[n].u.ubid))
	goto found;
	break;
	case KEYDB_SEARCH_MODE_FIRST:
	goto found;
	break;
	case KEYDB_SEARCH_MODE_NEXT:
	goto found;
	break;
	default:
	rc = gpg_error (GPG_ERR_INV_VALUE);
	goto found;
	}
	}
	continue;
	found:
	/* Record which DESC we matched on. Note this value is only
	meaningful if this function returns with no errors. */
	if(r_descindex)
	*r_descindex = n;
	for (n=any_skip?0:ndesc; n < ndesc; n++)
	{
	u32 kid[2];

	if (desc[n].skipfnc
	&& blob_get_first_keyid (blob, kid)
	&& desc[n].skipfnc (desc[n].skipfncvalue, kid, uid_no))
	break;
	}
	if (n == ndesc)
	break; /* got it */
	}

	if (!rc)
	{
	hd->found.blob = blob;
	hd->found.pk_no = pk_no;
	hd->found.uid_no = uid_no;
	}
	else if (rc == -1 \|\| gpg_err_code (rc) == GPG_ERR_EOF)
	{
	_keybox_release_blob (blob);
	hd->eof = 1;
	}
	else
	{
	_keybox_release_blob (blob);
	hd->error = rc;
	}

	if (sn_array)
	release_sn_array (sn_array, ndesc);

	return rc;
	}




	/*
	- Functions to return a certificate or a keyblock. To be used after
	- a successful search operation.
	-*/
	+ * Functions to return a certificate or a keyblock. To be used after
	+ * a successful search operation.
	+ */

	/* Return the raw data from the last found blob. Caller must release
	* the value stored at R_BUFFER. If called with NULL for R_BUFFER
	* only the needed length for the buffer and the public key type is
	- * returned. */
	+ * returned. R_PUBKEY_TYPE and R_UBID can be used to return these
	+ * attributes. */
	gpg_error_t
	keybox_get_data (KEYBOX_HANDLE hd, void *r_buffer, size_t r_length,
	- enum pubkey_types *r_pubkey_type)
	+ enum pubkey_types r_pubkey_type, unsigned char r_ubid)
	{
	const unsigned char *buffer;
	size_t length;
	size_t image_off, image_len;

	if (r_buffer)
	*r_buffer = NULL;
	if (r_length)
	*r_length = 0;
	if (r_pubkey_type)
	*r_pubkey_type = PUBKEY_TYPE_UNKNOWN;

	if (!hd)
	return gpg_error (GPG_ERR_INV_VALUE);
	if (!hd->found.blob)
	return gpg_error (GPG_ERR_NOTHING_FOUND);

	switch (blob_get_type (hd->found.blob))
	{
	case KEYBOX_BLOBTYPE_PGP:
	if (r_pubkey_type)
	*r_pubkey_type = PUBKEY_TYPE_OPGP;
	break;
	case KEYBOX_BLOBTYPE_X509:
	if (r_pubkey_type)
	*r_pubkey_type = PUBKEY_TYPE_X509;
	break;
	default:
	return gpg_error (GPG_ERR_WRONG_BLOB_TYPE);
	}

	buffer = _keybox_get_blob_image (hd->found.blob, &length);
	if (length < 40)
	return gpg_error (GPG_ERR_TOO_SHORT);
	image_off = get32 (buffer+8);
	image_len = get32 (buffer+12);
	if ((uint64_t)image_off+(uint64_t)image_len > (uint64_t)length)
	return gpg_error (GPG_ERR_TOO_SHORT);

	+ if (r_ubid)
	+ {
	+ size_t keyinfolen;
	+
	+ /* We do a quick but sufficient consistency check. For the full
	+ * check see blob_cmp_ubid. */
	+ if (!get16 (buffer + 16) /* No keys. */
	+ \|\| (keyinfolen = get16 (buffer + 18)) < 28
	+ \|\| (20 + (uint64_t)keyinfolen) > (uint64_t)length)
	+ return gpg_error (GPG_ERR_TOO_SHORT);
	+
	+ memcpy (r_ubid, buffer + 20, UBID_LEN);
	+ }
	+
	if (r_length)
	*r_length = image_len;
	if (r_buffer)
	{
	*r_buffer = xtrymalloc (image_len);
	if (!*r_buffer)
	return gpg_error_from_syserror ();
	memcpy (*r_buffer, buffer + image_off, image_len);
	}

	return 0;
	}


	/* Return the last found keyblock. Returns 0 on success and stores a
	* new iobuf at R_IOBUF. R_UID_NO and R_PK_NO are used to return the
	* index of the key or user id which matched the search criteria; if
	* not known they are set to 0. */
	gpg_error_t
	keybox_get_keyblock (KEYBOX_HANDLE hd, iobuf_t *r_iobuf,
	int r_pk_no, int r_uid_no)
	{
	gpg_error_t err;
	const unsigned char *buffer;
	size_t length;
	size_t image_off, image_len;
	size_t siginfo_off, siginfo_len;

	*r_iobuf = NULL;

	if (!hd)
	return gpg_error (GPG_ERR_INV_VALUE);
	if (!hd->found.blob)
	return gpg_error (GPG_ERR_NOTHING_FOUND);

	if (blob_get_type (hd->found.blob) != KEYBOX_BLOBTYPE_PGP)
	return gpg_error (GPG_ERR_WRONG_BLOB_TYPE);

	buffer = _keybox_get_blob_image (hd->found.blob, &length);
	if (length < 40)
	return gpg_error (GPG_ERR_TOO_SHORT);
	image_off = get32 (buffer+8);
	image_len = get32 (buffer+12);
	if ((uint64_t)image_off+(uint64_t)image_len > (uint64_t)length)
	return gpg_error (GPG_ERR_TOO_SHORT);

	err = _keybox_get_flag_location (buffer, length, KEYBOX_FLAG_SIG_INFO,
	&siginfo_off, &siginfo_len);
	if (err)
	return err;

	*r_pk_no = hd->found.pk_no;
	*r_uid_no = hd->found.uid_no;
	*r_iobuf = iobuf_temp_with_content (buffer+image_off, image_len);
	return 0;
	}


	#ifdef KEYBOX_WITH_X509
	/*
	Return the last found cert. Caller must free it.
	*/
	int
	keybox_get_cert (KEYBOX_HANDLE hd, ksba_cert_t *r_cert)
	{
	const unsigned char *buffer;
	size_t length;
	size_t cert_off, cert_len;
	ksba_reader_t reader = NULL;
	ksba_cert_t cert = NULL;
	int rc;

	if (!hd)
	return gpg_error (GPG_ERR_INV_VALUE);
	if (!hd->found.blob)
	return gpg_error (GPG_ERR_NOTHING_FOUND);

	if (blob_get_type (hd->found.blob) != KEYBOX_BLOBTYPE_X509)
	return gpg_error (GPG_ERR_WRONG_BLOB_TYPE);

	buffer = _keybox_get_blob_image (hd->found.blob, &length);
	if (length < 40)
	return gpg_error (GPG_ERR_TOO_SHORT);
	cert_off = get32 (buffer+8);
	cert_len = get32 (buffer+12);
	if ((uint64_t)cert_off+(uint64_t)cert_len > (uint64_t)length)
	return gpg_error (GPG_ERR_TOO_SHORT);

	rc = ksba_reader_new (&reader);
	if (rc)
	return rc;
	rc = ksba_reader_set_mem (reader, buffer+cert_off, cert_len);
	if (rc)
	{
	ksba_reader_release (reader);
	/* fixme: need to map the error codes */
	return gpg_error (GPG_ERR_GENERAL);
	}

	rc = ksba_cert_new (&cert);
	if (rc)
	{
	ksba_reader_release (reader);
	return rc;
	}

	rc = ksba_cert_read_der (cert, reader);
	if (rc)
	{
	ksba_cert_release (cert);
	ksba_reader_release (reader);
	/* fixme: need to map the error codes */
	return gpg_error (GPG_ERR_GENERAL);
	}

	*r_cert = cert;
	ksba_reader_release (reader);
	return 0;
	}

	#endif /KEYBOX_WITH_X509/

	/* Return the flags named WHAT at the address of VALUE. IDX is used
	only for certain flags and should be 0 if not required. */
	int
	keybox_get_flags (KEYBOX_HANDLE hd, int what, int idx, unsigned int *value)
	{
	const unsigned char *buffer;
	size_t length;
	gpg_err_code_t ec;

	(void)idx; /* Not yet used. */

	if (!hd)
	return gpg_error (GPG_ERR_INV_VALUE);
	if (!hd->found.blob)
	return gpg_error (GPG_ERR_NOTHING_FOUND);

	buffer = _keybox_get_blob_image (hd->found.blob, &length);
	ec = get_flag_from_image (buffer, length, what, value);
	return ec? gpg_error (ec):0;
	}

	off_t
	keybox_offset (KEYBOX_HANDLE hd)
	{
	if (!hd->fp)
	return 0;
	return ftello (hd->fp);
	}

	gpg_error_t
	keybox_seek (KEYBOX_HANDLE hd, off_t offset)
	{
	gpg_error_t err;

	if (hd->error)
	return hd->error; /* still in error state */

	if (! hd->fp)
	{
	if (!offset)
	{
	/* No need to open the file. An unopened file is effectively at
	offset 0. */
	return 0;
	}

	err = open_file (hd);
	if (err)
	return err;
	}

	err = fseeko (hd->fp, offset, SEEK_SET);
	hd->error = gpg_error_from_errno (err);

	return hd->error;
	}
	diff --git a/kbx/keybox.h b/kbx/keybox.h
	index b57823a98..6e5a51c63 100644
	--- a/kbx/keybox.h
	+++ b/kbx/keybox.h
	@@ -1,141 +1,142 @@
	/* keybox.h - Keybox operations
	* Copyright (C) 2001, 2003, 2012 Free Software Foundation, Inc.
	*
	* 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 KEYBOX_H
	#define KEYBOX_H 1
	#ifdef __cplusplus
	extern "C" {
	#if 0
	}
	#endif
	#endif

	#include "../common/iobuf.h"
	#include "keybox-search-desc.h"

	#ifdef KEYBOX_WITH_X509
	# include <ksba.h>
	#endif

	typedef struct keybox_handle *KEYBOX_HANDLE;


	typedef enum
	{
	KEYBOX_FLAG_BLOB, /* The blob flags. */
	KEYBOX_FLAG_VALIDITY, /* The validity of the entire key. */
	KEYBOX_FLAG_OWNERTRUST, /* The assigned ownertrust. */
	KEYBOX_FLAG_KEY, /* The key flags; requires a key index. */
	KEYBOX_FLAG_UID, /* The user ID flags; requires an uid index. */
	KEYBOX_FLAG_UID_VALIDITY,/* The validity of a specific uid, requires
	an uid index. */
	KEYBOX_FLAG_CREATED_AT, /* The date the block was created. */
	KEYBOX_FLAG_SIG_INFO, /* The signature info block. */
	} keybox_flag_t;

	/* Flag values used with KEYBOX_FLAG_BLOB. */
	#define KEYBOX_FLAG_BLOB_SECRET 1
	#define KEYBOX_FLAG_BLOB_EPHEMERAL 2

	/* The keybox blob types. */
	typedef enum
	{
	KEYBOX_BLOBTYPE_EMPTY = 0,
	KEYBOX_BLOBTYPE_HEADER = 1,
	KEYBOX_BLOBTYPE_PGP = 2,
	KEYBOX_BLOBTYPE_X509 = 3
	} keybox_blobtype_t;


	/-- keybox-init.c --/
	gpg_error_t keybox_register_file (const char *fname, int secret,
	void **r_token);
	int keybox_is_writable (void *token);

	KEYBOX_HANDLE keybox_new_openpgp (void *token, int secret);
	KEYBOX_HANDLE keybox_new_x509 (void *token, int secret);
	void keybox_release (KEYBOX_HANDLE hd);
	void keybox_push_found_state (KEYBOX_HANDLE hd);
	void keybox_pop_found_state (KEYBOX_HANDLE hd);
	const char *keybox_get_resource_name (KEYBOX_HANDLE hd);
	int keybox_set_ephemeral (KEYBOX_HANDLE hd, int yes);

	gpg_error_t keybox_lock (KEYBOX_HANDLE hd, int yes, long timeout);

	/-- keybox-file.c --/
	/* Fixme: This function does not belong here: Provide a better
	interface to create a new keybox file. */
	gpg_error_t _keybox_write_header_blob (FILE *fp, estream_t stream,
	int openpgp_flag);

	/-- keybox-search.c --/
	gpg_error_t keybox_get_data (KEYBOX_HANDLE hd,
	void *r_buffer, size_t r_length,
	- enum pubkey_types *r_pubkey_type);
	+ enum pubkey_types *r_pubkey_type,
	+ unsigned char *r_ubid);
	gpg_error_t keybox_get_keyblock (KEYBOX_HANDLE hd, iobuf_t *r_iobuf,
	int r_pk_no, int r_uid_no);
	#ifdef KEYBOX_WITH_X509
	int keybox_get_cert (KEYBOX_HANDLE hd, ksba_cert_t *ret_cert);
	#endif /KEYBOX_WITH_X509/
	int keybox_get_flags (KEYBOX_HANDLE hd, int what, int idx, unsigned int *value);

	gpg_error_t keybox_search_reset (KEYBOX_HANDLE hd);
	gpg_error_t keybox_search (KEYBOX_HANDLE hd,
	KEYBOX_SEARCH_DESC *desc, size_t ndesc,
	keybox_blobtype_t want_blobtype,
	size_t r_descindex, unsigned long r_skipped);

	off_t keybox_offset (KEYBOX_HANDLE hd);
	gpg_error_t keybox_seek (KEYBOX_HANDLE hd, off_t offset);

	/-- keybox-update.c --/
	gpg_error_t keybox_insert_keyblock (KEYBOX_HANDLE hd,
	const void *image, size_t imagelen);
	gpg_error_t keybox_update_keyblock (KEYBOX_HANDLE hd,
	const void *image, size_t imagelen);

	#ifdef KEYBOX_WITH_X509
	int keybox_insert_cert (KEYBOX_HANDLE hd, ksba_cert_t cert,
	unsigned char *sha1_digest);
	int keybox_update_cert (KEYBOX_HANDLE hd, ksba_cert_t cert,
	unsigned char *sha1_digest);
	#endif /KEYBOX_WITH_X509/
	int keybox_set_flags (KEYBOX_HANDLE hd, int what, int idx, unsigned int value);

	int keybox_delete (KEYBOX_HANDLE hd);
	int keybox_compress (KEYBOX_HANDLE hd);


	/-- --/

	#if 0
	int keybox_locate_writable (KEYBOX_HANDLE hd);
	int keybox_rebuild_cache (void *);
	#endif


	/-- keybox-util.c --/
	gpg_error_t keybox_tmp_names (const char *filename, int for_keyring,
	char r_bakname, char r_tmpname);


	#ifdef __cplusplus
	}
	#endif
	#endif /KEYBOX_H/

File Metadata

Mime Type: text/x-diff
Expires: Mon, Dec 8, 11:40 AM (4 h, 35 m)
Storage Engine: local-disk
Storage Format: Raw Data
Storage Handle: 13/9d/af0cfd7284dd6c4fbd1e22475999

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions