No OneTemporary
Actions

Size

206 KB

Subscribers

None

View Options

	diff --git a/g10/Makefile.am b/g10/Makefile.am
	index 884b4749b..ba297cfc9 100644
	--- a/g10/Makefile.am
	+++ b/g10/Makefile.am
	@@ -1,260 +1,261 @@
	# Copyright (C) 1998, 1999, 2000, 2001, 2002,
	# 2003, 2006, 2010 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/>.

	## Process this file with automake to produce Makefile.in

	EXTRA_DIST = distsigkey.gpg \
	ChangeLog-2011 gpg-w32info.rc \
	gpg.w32-manifest.in test.c t-keydb-keyring.kbx \
	t-keydb-get-keyblock.gpg t-stutter-data.asc \
	all-tests.scm

	AM_CPPFLAGS =

	include $(top_srcdir)/am/cmacros.am

	AM_CFLAGS = $(SQLITE3_CFLAGS) $(LIBGCRYPT_CFLAGS) \
	$(LIBASSUAN_CFLAGS) $(GPG_ERROR_CFLAGS)

	needed_libs = ../kbx/libkeybox.a $(libcommon)

	# Because there are no program specific transform macros we need to
	# work around that to allow installing gpg as gpg2.
	gpg2_hack_list = gpg gpgv
	if USE_GPG2_HACK
	gpg2_hack_uninst = gpg2 gpgv2
	use_gpg2_hack = yes
	else
	gpg2_hack_uninst = $(gpg2_hack_list)
	use_gpg2_hack = no
	endif

	# NB: We use noinst_ for gpg and gpgv so that we can install them with
	# the install-hook target under the name gpg2/gpgv2.
	noinst_PROGRAMS = gpg
	if !HAVE_W32CE_SYSTEM
	noinst_PROGRAMS += gpgv
	endif
	if MAINTAINER_MODE
	noinst_PROGRAMS += gpgcompose
	endif
	noinst_PROGRAMS += $(module_tests)
	TESTS = $(module_tests)
	TESTS_ENVIRONMENT = \
	abs_top_srcdir=$(abs_top_srcdir)

	if ENABLE_BZIP2_SUPPORT
	bzip2_source = compress-bz2.c
	else
	bzip2_source =
	endif

	if ENABLE_CARD_SUPPORT
	card_source = card-util.c
	else
	card_source =
	endif

	if NO_TRUST_MODELS
	trust_source =
	else
	trust_source = trustdb.c trustdb.h tdbdump.c tdbio.c tdbio.h
	endif

	if USE_TOFU
	tofu_source = tofu.h tofu.c gpgsql.c gpgsql.h
	else
	tofu_source =
	endif


	if HAVE_W32_SYSTEM
	resource_objs += gpg-w32info.o

	gpg-w32info.o : gpg.w32-manifest

	endif

	common_source = \
	gpg.h \
	dek.h \
	build-packet.c \
	compress.c \
	$(bzip2_source) \
	filter.h \
	free-packet.c \
	getkey.c \
	+ expand-group.c \
	keydb.c keydb.h \
	keyring.c keyring.h \
	seskey.c \
	kbnode.c \
	main.h \
	mainproc.c \
	armor.c \
	mdfilter.c \
	textfilter.c \
	progress.c \
	misc.c \
	rmd160.c rmd160.h \
	options.h \
	openfile.c \
	keyid.c \
	packet.h \
	parse-packet.c \
	cpr.c \
	plaintext.c \
	sig-check.c \
	keylist.c \
	pkglue.c pkglue.h \
	objcache.c objcache.h \
	ecdh.c

	gpg_sources = server.c \
	$(common_source) \
	pkclist.c \
	skclist.c \
	pubkey-enc.c \
	passphrase.c \
	decrypt.c \
	decrypt-data.c \
	cipher-cfb.c \
	cipher-aead.c \
	encrypt.c \
	sign.c \
	verify.c \
	revoke.c \
	dearmor.c \
	import.c \
	export.c \
	migrate.c \
	delkey.c \
	keygen.c \
	helptext.c \
	keyserver.c \
	keyserver-internal.h \
	call-dirmngr.c call-dirmngr.h \
	photoid.c photoid.h \
	call-agent.c call-agent.h \
	trust.c $(trust_source) $(tofu_source) \
	$(card_source) \
	exec.c exec.h \
	key-clean.c key-clean.h \
	key-check.c key-check.h

	gpg_SOURCES = gpg.c \
	keyedit.c keyedit.h \
	$(gpg_sources)

	gpgcompose_SOURCES = gpgcompose.c $(gpg_sources)
	gpgv_SOURCES = gpgv.c \
	$(common_source) \
	verify.c

	#gpgd_SOURCES = gpgd.c \
	# ks-proto.h \
	# ks-proto.c \
	# ks-db.c \
	# ks-db.h \
	# $(common_source)

	LDADD = $(needed_libs) ../common/libgpgrl.a \
	$(ZLIBS) $(LIBINTL) $(CAPLIBS) $(NETLIBS)
	gpg_LDADD = $(LDADD) $(SQLITE3_LIBS) $(LIBGCRYPT_LIBS) $(LIBREADLINE) \
	$(LIBASSUAN_LIBS) $(GPG_ERROR_LIBS) \
	$(LIBICONV) $(resource_objs) $(extra_sys_libs)
	gpg_LDFLAGS = $(extra_bin_ldflags)
	gpgv_LDADD = $(LDADD) $(LIBGCRYPT_LIBS) \
	$(GPG_ERROR_LIBS) \
	$(LIBICONV) $(resource_objs) $(extra_sys_libs)
	gpgv_LDFLAGS = $(extra_bin_ldflags)

	gpgcompose_LDADD = $(LDADD) $(SQLITE3_LIBS) $(LIBGCRYPT_LIBS) $(LIBREADLINE) \
	$(LIBASSUAN_LIBS) $(GPG_ERROR_LIBS) \
	$(LIBICONV) $(resource_objs) $(extra_sys_libs)
	gpgcompose_LDFLAGS = $(extra_bin_ldflags)

	t_common_ldadd =
	module_tests = t-rmd160 t-keydb t-keydb-get-keyblock t-stutter
	t_rmd160_SOURCES = t-rmd160.c rmd160.c
	t_rmd160_LDADD = $(t_common_ldadd)
	t_keydb_SOURCES = t-keydb.c test-stubs.c $(common_source)
	t_keydb_LDADD = $(LDADD) $(LIBGCRYPT_LIBS) $(GPG_ERROR_LIBS) \
	$(LIBICONV) $(t_common_ldadd)
	t_keydb_get_keyblock_SOURCES = t-keydb-get-keyblock.c test-stubs.c \
	$(common_source)
	t_keydb_get_keyblock_LDADD = $(LDADD) $(LIBGCRYPT_LIBS) $(GPG_ERROR_LIBS) \
	$(LIBICONV) $(t_common_ldadd)
	t_stutter_SOURCES = t-stutter.c test-stubs.c \
	$(common_source)
	t_stutter_LDADD = $(LDADD) $(LIBGCRYPT_LIBS) $(GPG_ERROR_LIBS) \
	$(LIBICONV) $(t_common_ldadd)


	$(PROGRAMS): $(needed_libs) ../common/libgpgrl.a

	# NB: To install gpg and gpgv we use this -hook. This code has to
	# duplicate most of the automake generated install-binPROGRAMS target
	# so that directories are created and the transform feature works.
	install-exec-hook:
	@echo "running install-exec-hook"; \
	echo " $(MKDIR_P) '$(DESTDIR)$(bindir)'"; \
	$(MKDIR_P) "$(DESTDIR)$(bindir)"; \
	for p in $(gpg2_hack_list); do \
	echo "$$p$(EXEEXT) $$p$(EXEEXT)"; done \| \
	sed 's/$(EXEEXT)$$//' \| \
	while read p p1; do if test -f $$p \
	; then echo "$$p"; echo "$$p"; else :; fi; \
	done \| \
	sed -e 'p;s,.*/,,;n;h' \
	-e 's\|.*\|.\|' \
	-e 'p;x;s,.*/,,;s/$(EXEEXT)$$//;$(transform);s/$$/$(EXEEXT)/' \| \
	sed 'N;N;N;s,\n, ,g' \| \
	$(AWK) 'BEGIN { files["."] = ""; dirs["."] = 1 } \
	{ d=$$3; if (dirs[d] != 1) { print "d", d; dirs[d] = 1 } \
	if ($$2 == $$4) files[d] = files[d] " " $$1; \
	else { print "f", $$3 "/" $$4, $$1; } } \
	END { for (d in files) print "f", d, files[d] }' \| \
	while read type dir files; do \
	for f in $$files; do \
	if test $(use_gpg2_hack) = yes ; \
	then f2=`echo "$${f}" \| sed 's/$(EXEEXT)$$//'`2$(EXEEXT); \
	else f2="$${f}" ;\
	fi ; \
	echo "$(INSTALL_PROGRAM_ENV) $(INSTALL_PROGRAM) \
	$${f} '$(DESTDIR)$(bindir)/$${f2}'"; \
	$(INSTALL_PROGRAM_ENV) $(INSTALL_PROGRAM) \
	$${f} "$(DESTDIR)$(bindir)/$${f2}"; \
	done; \
	done


	install-data-local:
	$(mkinstalldirs) $(DESTDIR)$(pkgdatadir)
	$(INSTALL_DATA) $(srcdir)/distsigkey.gpg \
	$(DESTDIR)$(pkgdatadir)/distsigkey.gpg

	# NB: For uninstalling gpg and gpgv we use -local because there is
	# no need for a specific order the targets need to be run.
	uninstall-local:
	-@rm $(DESTDIR)$(pkgdatadir)/distsigkey.gpg
	-@files=`for p in $(gpg2_hack_uninst); do echo "$$p"; done \| \
	sed -e 'h;s,^.*/,,;s/$(EXEEXT)$$//;$(transform)' \
	-e 's/$$/$(EXEEXT)/' \
	`; \
	echo " ( cd '$(DESTDIR)$(bindir)' && rm -f" $$files ")"; \
	cd "$(DESTDIR)$(bindir)" && rm -f $$files
	diff --git a/g10/expand-group.c b/g10/expand-group.c
	new file mode 100644
	index 000000000..e09a4fff6
	--- /dev/null
	+++ b/g10/expand-group.c
	@@ -0,0 +1,73 @@
	+/* expand-group.c - expand GPG group definitions
	+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
	+ * 2008, 2009, 2010 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 "gpg.h"
	+#include "options.h"
	+#include "keydb.h"
	+
	+int
	+expand_id (const char id, strlist_t into, unsigned int flags)
	+{
	+ struct groupitem *groups;
	+ int count=0;
	+
	+ for (groups = opt.grouplist; groups; groups=groups->next)
	+ {
	+ /* need strcasecmp() here, as this should be localized */
	+ if (strcasecmp (groups->name,id) == 0)
	+ {
	+ strlist_t each,sl;
	+
	+ /* This maintains the current utf8-ness */
	+ for (each = groups->values; each; each=each->next)
	+ {
	+ sl = add_to_strlist (into, each->d);
	+ sl->flags = flags;
	+ count++;
	+ }
	+
	+ break;
	+ }
	+ }
	+
	+ return count;
	+}
	+
	+/* For simplicity, and to avoid potential loops, we only expand once -
	+ * you can't make an alias that points to an alias. */
	+strlist_t
	+expand_group (strlist_t input)
	+{
	+ strlist_t output = NULL;
	+ strlist_t sl, rover;
	+
	+ for (rover = input; rover; rover = rover->next)
	+ if (!(rover->flags & PK_LIST_FROM_FILE)
	+ && !expand_id (rover->d, &output, rover->flags))
	+ {
	+ /* Didn't find any groups, so use the existing string */
	+ sl = add_to_strlist (&output, rover->d);
	+ sl->flags = rover->flags;
	+ }
	+
	+ return output;
	+}
	diff --git a/g10/getkey.c b/g10/getkey.c
	index 55cb6d090..2bf42a677 100644
	--- a/g10/getkey.c
	+++ b/g10/getkey.c
	@@ -1,4152 +1,4172 @@
	/* getkey.c - Get a key from the database
	* Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
	* 2007, 2008, 2010 Free Software Foundation, Inc.
	* Copyright (C) 2015, 2016 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/>.
	*/

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

	#include "gpg.h"
	#include "../common/util.h"
	#include "packet.h"
	#include "../common/iobuf.h"
	#include "keydb.h"
	#include "options.h"
	#include "main.h"
	#include "trustdb.h"
	#include "../common/i18n.h"
	#include "keyserver-internal.h"
	#include "call-agent.h"
	#include "objcache.h"
	#include "../common/host2net.h"
	#include "../common/mbox-util.h"
	#include "../common/status.h"

	#define MAX_PK_CACHE_ENTRIES PK_UID_CACHE_SIZE
	#define MAX_UID_CACHE_ENTRIES PK_UID_CACHE_SIZE

	#if MAX_PK_CACHE_ENTRIES < 2
	#error We need the cache for key creation
	#endif

	/* Flags values returned by the lookup code. Note that the values are
	* directly used by the KEY_CONSIDERED status line. */
	#define LOOKUP_NOT_SELECTED (1<<0)
	#define LOOKUP_ALL_SUBKEYS_EXPIRED (1<<1) /* or revoked */


	/* A context object used by the lookup functions. */
	struct getkey_ctx_s
	{
	/* Part of the search criteria: whether the search is an exact
	search or not. A search that is exact requires that a key or
	subkey meet all of the specified criteria. A search that is not
	exact allows selecting a different key or subkey from the
	keyblock that matched the criteria. Further, an exact search
	returns the key or subkey that matched whereas a non-exact search
	typically returns the primary key. See finish_lookup for
	details. */
	int exact;

	/* Part of the search criteria: Whether the caller only wants keys
	with an available secret key. This is used by getkey_next to get
	the next result with the same initial criteria. */
	int want_secret;

	/* Part of the search criteria: The type of the requested key. A
	mask of PUBKEY_USAGE_SIG, PUBKEY_USAGE_ENC and PUBKEY_USAGE_CERT.
	If non-zero, then for a key to match, it must implement one of
	the required uses. */
	int req_usage;

	/* The database handle. */
	KEYDB_HANDLE kr_handle;

	/* Whether we should call xfree() on the context when the context is
	released using getkey_end()). */
	int not_allocated;

	/* This variable is used as backing store for strings which have
	their address used in ITEMS. */
	strlist_t extra_list;

	/* Hack to return the mechanism (AKL_foo) used to find the key. */
	int found_via_akl;

	/* Part of the search criteria: The low-level search specification
	as passed to keydb_search. */
	int nitems;
	/* This must be the last element in the structure. When we allocate
	the structure, we allocate it so that ITEMS can hold NITEMS. */
	KEYDB_SEARCH_DESC items[1];
	};

	#if 0
	static struct
	{
	int any;
	int okay_count;
	int nokey_count;
	int error_count;
	} lkup_stats[21];
	#endif

	typedef struct keyid_list
	{
	struct keyid_list *next;
	byte fprlen;
	char fpr[MAX_FINGERPRINT_LEN];
	u32 keyid[2];
	} *keyid_list_t;


	#if MAX_PK_CACHE_ENTRIES
	typedef struct pk_cache_entry
	{
	struct pk_cache_entry *next;
	u32 keyid[2];
	PKT_public_key *pk;
	} *pk_cache_entry_t;
	static pk_cache_entry_t pk_cache;
	static int pk_cache_entries; /* Number of entries in pk cache. */
	static int pk_cache_disabled;
	#endif

	#if MAX_UID_CACHE_ENTRIES < 5
	#error we really need the userid cache
	#endif

	static void merge_selfsigs (ctrl_t ctrl, kbnode_t keyblock);
	static int lookup (ctrl_t ctrl, getkey_ctx_t ctx, int want_secret,
	kbnode_t ret_keyblock, kbnode_t ret_found_key);
	static kbnode_t finish_lookup (kbnode_t keyblock,
	unsigned int req_usage, int want_exact,
	int want_secret, unsigned int *r_flags);
	static void print_status_key_considered (kbnode_t keyblock, unsigned int flags);


	#if 0
	static void
	print_stats ()
	{
	int i;
	for (i = 0; i < DIM (lkup_stats); i++)
	{
	if (lkup_stats[i].any)
	es_fprintf (es_stderr,
	"lookup stats: mode=%-2d ok=%-6d nokey=%-6d err=%-6d\n",
	i,
	lkup_stats[i].okay_count,
	lkup_stats[i].nokey_count, lkup_stats[i].error_count);
	}
	}
	#endif


	/* Cache a copy of a public key in the public key cache. PK is not
	* cached if caching is disabled (via getkey_disable_caches), if
	* PK->FLAGS.DONT_CACHE is set, we don't know how to derive a key id
	* from the public key (e.g., unsupported algorithm), or a key with
	* the key id is already in the cache.
	*
	* The public key packet is copied into the cache using
	* copy_public_key. Thus, any secret parts are not copied, for
	* instance.
	*
	* This cache is filled by get_pubkey and is read by get_pubkey and
	* get_pubkey_fast. */
	void
	cache_public_key (PKT_public_key * pk)
	{
	#if MAX_PK_CACHE_ENTRIES
	pk_cache_entry_t ce, ce2;
	u32 keyid[2];

	if (pk_cache_disabled)
	return;

	if (pk->flags.dont_cache)
	return;

	if (is_ELGAMAL (pk->pubkey_algo)
	\|\| pk->pubkey_algo == PUBKEY_ALGO_DSA
	\|\| pk->pubkey_algo == PUBKEY_ALGO_ECDSA
	\|\| pk->pubkey_algo == PUBKEY_ALGO_EDDSA
	\|\| pk->pubkey_algo == PUBKEY_ALGO_ECDH
	\|\| is_RSA (pk->pubkey_algo))
	{
	keyid_from_pk (pk, keyid);
	}
	else
	return; /* Don't know how to get the keyid. */

	for (ce = pk_cache; ce; ce = ce->next)
	if (ce->keyid[0] == keyid[0] && ce->keyid[1] == keyid[1])
	{
	if (DBG_CACHE)
	log_debug ("cache_public_key: already in cache\n");
	return;
	}

	if (pk_cache_entries >= MAX_PK_CACHE_ENTRIES)
	{
	int n;

	/* Remove the last 50% of the entries. */
	for (ce = pk_cache, n = 0; ce && n < pk_cache_entries/2; n++)
	ce = ce->next;
	if (ce && ce != pk_cache && ce->next)
	{
	ce2 = ce->next;
	ce->next = NULL;
	ce = ce2;
	for (; ce; ce = ce2)
	{
	ce2 = ce->next;
	free_public_key (ce->pk);
	xfree (ce);
	pk_cache_entries--;
	}
	}
	log_assert (pk_cache_entries < MAX_PK_CACHE_ENTRIES);
	}
	pk_cache_entries++;
	ce = xmalloc (sizeof *ce);
	ce->next = pk_cache;
	pk_cache = ce;
	ce->pk = copy_public_key (NULL, pk);
	ce->keyid[0] = keyid[0];
	ce->keyid[1] = keyid[1];
	#endif
	}


	/* Return a const utf-8 string with the text "[User ID not found]".
	This function is required so that we don't need to switch gettext's
	encoding temporary. */
	static const char *
	user_id_not_found_utf8 (void)
	{
	static char *text;

	if (!text)
	text = native_to_utf8 (_("[User ID not found]"));
	return text;
	}




	/* Disable and drop the public key cache (which is filled by
	cache_public_key and get_pubkey). Note: there is currently no way
	to re-enable this cache. */
	void
	getkey_disable_caches ()
	{
	#if MAX_PK_CACHE_ENTRIES
	{
	pk_cache_entry_t ce, ce2;

	for (ce = pk_cache; ce; ce = ce2)
	{
	ce2 = ce->next;
	free_public_key (ce->pk);
	xfree (ce);
	}
	pk_cache_disabled = 1;
	pk_cache_entries = 0;
	pk_cache = NULL;
	}
	#endif
	/* fixme: disable user id cache ? */
	}


	/* Free a list of pubkey_t objects. */
	void
	pubkeys_free (pubkey_t keys)
	{
	while (keys)
	{
	pubkey_t next = keys->next;
	xfree (keys->pk);
	release_kbnode (keys->keyblock);
	xfree (keys);
	keys = next;
	}
	}


	static void
	pk_from_block (PKT_public_key *pk, kbnode_t keyblock, kbnode_t found_key)
	{
	kbnode_t a = found_key ? found_key : keyblock;

	log_assert (a->pkt->pkttype == PKT_PUBLIC_KEY
	\|\| a->pkt->pkttype == PKT_PUBLIC_SUBKEY);

	copy_public_key (pk, a->pkt->pkt.public_key);
	}


	/* Specialized version of get_pubkey which retrieves the key based on
	* information in SIG. In contrast to get_pubkey PK is required. */
	gpg_error_t
	get_pubkey_for_sig (ctrl_t ctrl, PKT_public_key pk, PKT_signature sig)
	{
	const byte *fpr;
	size_t fprlen;

	/* First try the new ISSUER_FPR info. */
	fpr = issuer_fpr_raw (sig, &fprlen);
	if (fpr && !get_pubkey_byfprint (ctrl, pk, NULL, fpr, fprlen))
	return 0;

	/* Fallback to use the ISSUER_KEYID. */
	return get_pubkey (ctrl, pk, sig->keyid);
	}


	/* Return the public key with the key id KEYID and store it at PK.
	* The resources in *PK should be released using
	* release_public_key_parts(). This function also stores a copy of
	* the public key in the user id cache (see cache_public_key).
	*
	* If PK is NULL, this function just stores the public key in the
	* cache and returns the usual return code.
	*
	* PK->REQ_USAGE (which is a mask of PUBKEY_USAGE_SIG,
	* PUBKEY_USAGE_ENC and PUBKEY_USAGE_CERT) is passed through to the
	* lookup function. If this is non-zero, only keys with the specified
	* usage will be returned. As such, it is essential that
	* PK->REQ_USAGE be correctly initialized!
	*
	* Returns 0 on success, GPG_ERR_NO_PUBKEY if there is no public key
	* with the specified key id, or another error code if an error
	* occurs.
	*
	* If the data was not read from the cache, then the self-signed data
	* has definitely been merged into the public key using
	* merge_selfsigs. */
	int
	get_pubkey (ctrl_t ctrl, PKT_public_key * pk, u32 * keyid)
	{
	int internal = 0;
	int rc = 0;

	#if MAX_PK_CACHE_ENTRIES
	if (pk)
	{
	/* Try to get it from the cache. We don't do this when pk is
	NULL as it does not guarantee that the user IDs are
	cached. */
	pk_cache_entry_t ce;
	for (ce = pk_cache; ce; ce = ce->next)
	{
	if (ce->keyid[0] == keyid[0] && ce->keyid[1] == keyid[1])
	/* XXX: We don't check PK->REQ_USAGE here, but if we don't
	read from the cache, we do check it! */
	{
	copy_public_key (pk, ce->pk);
	return 0;
	}
	}
	}
	#endif
	/* More init stuff. */
	if (!pk)
	{
	internal++;
	pk = xtrycalloc (1, sizeof *pk);
	if (!pk)
	{
	rc = gpg_error_from_syserror ();
	goto leave;
	}
	}


	/* Do a lookup. */
	{
	struct getkey_ctx_s ctx;
	kbnode_t kb = NULL;
	kbnode_t found_key = NULL;

	memset (&ctx, 0, sizeof ctx);
	ctx.exact = 1; /* Use the key ID exactly as given. */
	ctx.not_allocated = 1;

	if (ctrl && ctrl->cached_getkey_kdb)
	{
	ctx.kr_handle = ctrl->cached_getkey_kdb;
	ctrl->cached_getkey_kdb = NULL;
	keydb_search_reset (ctx.kr_handle);
	}
	else
	{
	ctx.kr_handle = keydb_new ();
	if (!ctx.kr_handle)
	{
	rc = gpg_error_from_syserror ();
	goto leave;
	}
	}
	ctx.nitems = 1;
	ctx.items[0].mode = KEYDB_SEARCH_MODE_LONG_KID;
	ctx.items[0].u.kid[0] = keyid[0];
	ctx.items[0].u.kid[1] = keyid[1];
	ctx.req_usage = pk->req_usage;
	rc = lookup (ctrl, &ctx, 0, &kb, &found_key);
	if (!rc)
	{
	pk_from_block (pk, kb, found_key);
	}
	getkey_end (ctrl, &ctx);
	release_kbnode (kb);
	}
	if (!rc)
	goto leave;

	rc = GPG_ERR_NO_PUBKEY;

	leave:
	if (!rc)
	cache_public_key (pk);
	if (internal)
	free_public_key (pk);
	return rc;
	}


	/* Similar to get_pubkey, but it does not take PK->REQ_USAGE into
	* account nor does it merge in the self-signed data. This function
	* also only considers primary keys. It is intended to be used as a
	* quick check of the key to avoid recursion. It should only be used
	* in very certain cases. Like get_pubkey and unlike any of the other
	* lookup functions, this function also consults the user id cache
	* (see cache_public_key).
	*
	* Return the public key in PK. The resources in PK should be
	* released using release_public_key_parts(). */
	int
	get_pubkey_fast (PKT_public_key * pk, u32 * keyid)
	{
	int rc = 0;
	KEYDB_HANDLE hd;
	KBNODE keyblock;
	u32 pkid[2];

	log_assert (pk);
	#if MAX_PK_CACHE_ENTRIES
	{
	/* Try to get it from the cache */
	pk_cache_entry_t ce;

	for (ce = pk_cache; ce; ce = ce->next)
	{
	if (ce->keyid[0] == keyid[0] && ce->keyid[1] == keyid[1]
	/* Only consider primary keys. */
	&& ce->pk->keyid[0] == ce->pk->main_keyid[0]
	&& ce->pk->keyid[1] == ce->pk->main_keyid[1])
	{
	if (pk)
	copy_public_key (pk, ce->pk);
	return 0;
	}
	}
	}
	#endif

	hd = keydb_new ();
	if (!hd)
	return gpg_error_from_syserror ();
	rc = keydb_search_kid (hd, keyid);
	if (gpg_err_code (rc) == GPG_ERR_NOT_FOUND)
	{
	keydb_release (hd);
	return GPG_ERR_NO_PUBKEY;
	}
	rc = keydb_get_keyblock (hd, &keyblock);
	keydb_release (hd);
	if (rc)
	{
	log_error ("keydb_get_keyblock failed: %s\n", gpg_strerror (rc));
	return GPG_ERR_NO_PUBKEY;
	}

	log_assert (keyblock && keyblock->pkt
	&& keyblock->pkt->pkttype == PKT_PUBLIC_KEY);

	/* We return the primary key. If KEYID matched a subkey, then we
	return an error. */
	keyid_from_pk (keyblock->pkt->pkt.public_key, pkid);
	if (keyid[0] == pkid[0] && keyid[1] == pkid[1])
	copy_public_key (pk, keyblock->pkt->pkt.public_key);
	else
	rc = GPG_ERR_NO_PUBKEY;

	release_kbnode (keyblock);

	/* Not caching key here since it won't have all of the fields
	properly set. */

	return rc;
	}


	/* Return the entire keyblock used to create SIG. This is a
	* specialized version of get_pubkeyblock.
	*
	* FIXME: This is a hack because get_pubkey_for_sig was already called
	* and it could have used a cache to hold the key. */
	kbnode_t
	get_pubkeyblock_for_sig (ctrl_t ctrl, PKT_signature *sig)
	{
	const byte *fpr;
	size_t fprlen;
	kbnode_t keyblock;

	/* First try the new ISSUER_FPR info. */
	fpr = issuer_fpr_raw (sig, &fprlen);
	if (fpr && !get_pubkey_byfprint (ctrl, NULL, &keyblock, fpr, fprlen))
	return keyblock;

	/* Fallback to use the ISSUER_KEYID. */
	return get_pubkeyblock (ctrl, sig->keyid);
	}


	/* Return the key block for the key with key id KEYID or NULL, if an
	* error occurs. Use release_kbnode() to release the key block.
	*
	* The self-signed data has already been merged into the public key
	* using merge_selfsigs. */
	kbnode_t
	get_pubkeyblock (ctrl_t ctrl, u32 * keyid)
	{
	struct getkey_ctx_s ctx;
	int rc = 0;
	KBNODE keyblock = NULL;

	memset (&ctx, 0, sizeof ctx);
	/* No need to set exact here because we want the entire block. */
	ctx.not_allocated = 1;
	ctx.kr_handle = keydb_new ();
	if (!ctx.kr_handle)
	return NULL;
	ctx.nitems = 1;
	ctx.items[0].mode = KEYDB_SEARCH_MODE_LONG_KID;
	ctx.items[0].u.kid[0] = keyid[0];
	ctx.items[0].u.kid[1] = keyid[1];
	rc = lookup (ctrl, &ctx, 0, &keyblock, NULL);
	getkey_end (ctrl, &ctx);

	return rc ? NULL : keyblock;
	}


	/* Return the public key with the key id KEYID iff the secret key is
	* available and store it at PK. The resources should be released
	* using release_public_key_parts().
	*
	* Unlike other lookup functions, PK may not be NULL. PK->REQ_USAGE
	* is passed through to the lookup function and is a mask of
	* PUBKEY_USAGE_SIG, PUBKEY_USAGE_ENC and PUBKEY_USAGE_CERT. Thus, it
	* must be valid! If this is non-zero, only keys with the specified
	* usage will be returned.
	*
	* Returns 0 on success. If a public key with the specified key id is
	* not found or a secret key is not available for that public key, an
	* error code is returned. Note: this function ignores legacy keys.
	* An error code is also return if an error occurs.
	*
	* The self-signed data has already been merged into the public key
	* using merge_selfsigs. */
	gpg_error_t
	get_seckey (ctrl_t ctrl, PKT_public_key pk, u32 keyid)
	{
	gpg_error_t err;
	struct getkey_ctx_s ctx;
	kbnode_t keyblock = NULL;
	kbnode_t found_key = NULL;

	memset (&ctx, 0, sizeof ctx);
	ctx.exact = 1; /* Use the key ID exactly as given. */
	ctx.not_allocated = 1;
	ctx.kr_handle = keydb_new ();
	if (!ctx.kr_handle)
	return gpg_error_from_syserror ();
	ctx.nitems = 1;
	ctx.items[0].mode = KEYDB_SEARCH_MODE_LONG_KID;
	ctx.items[0].u.kid[0] = keyid[0];
	ctx.items[0].u.kid[1] = keyid[1];
	ctx.req_usage = pk->req_usage;
	err = lookup (ctrl, &ctx, 1, &keyblock, &found_key);
	if (!err)
	{
	pk_from_block (pk, keyblock, found_key);
	}
	getkey_end (ctrl, &ctx);
	release_kbnode (keyblock);

	if (!err)
	{
	err = agent_probe_secret_key (/ctrl/NULL, pk);
	if (err)
	release_public_key_parts (pk);
	}

	return err;
	}


	/* Skip unusable keys. A key is unusable if it is revoked, expired or
	disabled or if the selected user id is revoked or expired. */
	static int
	skip_unusable (void opaque, u32 keyid, int uid_no)
	{
	ctrl_t ctrl = opaque;
	int unusable = 0;
	KBNODE keyblock;
	PKT_public_key *pk;

	keyblock = get_pubkeyblock (ctrl, keyid);
	if (!keyblock)
	{
	log_error ("error checking usability status of %s\n", keystr (keyid));
	goto leave;
	}

	pk = keyblock->pkt->pkt.public_key;

	/* Is the key revoked or expired? */
	if (pk->flags.revoked \|\| pk->has_expired)
	unusable = 1;

	/* Is the user ID in question revoked or expired? */
	if (!unusable && uid_no)
	{
	KBNODE node;
	int uids_seen = 0;

	for (node = keyblock; node; node = node->next)
	{
	if (node->pkt->pkttype == PKT_USER_ID)
	{
	PKT_user_id *user_id = node->pkt->pkt.user_id;

	uids_seen ++;
	if (uids_seen != uid_no)
	continue;

	if (user_id->flags.revoked \|\| user_id->flags.expired)
	unusable = 1;

	break;
	}
	}

	/* If UID_NO is non-zero, then the keyblock better have at least
	that many UIDs. */
	log_assert (uids_seen == uid_no);
	}

	if (!unusable)
	unusable = pk_is_disabled (pk);

	leave:
	release_kbnode (keyblock);
	return unusable;
	}


	/* Search for keys matching some criteria.

	If RETCTX is not NULL, then the constructed context is returned in
	*RETCTX so that getpubkey_next can be used to get subsequent
	results. In this case, getkey_end() must be used to free the
	search context. If RETCTX is not NULL, then RET_KDBHD must be
	NULL.

	If NAMELIST is not NULL, then a search query is constructed using
	classify_user_id on each of the strings in the list. (Recall: the
	database does an OR of the terms, not an AND.) If NAMELIST is
	NULL, then all results are returned.

	If PK is not NULL, the public key of the first result is returned
	in *PK. Note: PK->REQ_USAGE must be valid!!! If PK->REQ_USAGE is
	set, it is used to filter the search results. See the
	documentation for finish_lookup to understand exactly how this is
	used. Note: The self-signed data has already been merged into the
	public key using merge_selfsigs. Free *PK by calling
	release_public_key_parts (or, if PK was allocated using xfree, you
	can use free_public_key, which calls release_public_key_parts(PK)
	and then xfree(PK)).

	If WANT_SECRET is set, then only keys with an available secret key
	(either locally or via key registered on a smartcard) are returned.

	If INCLUDE_UNUSABLE is set, then unusable keys (see the
	documentation for skip_unusable for an exact definition) are
	skipped unless they are looked up by key id or by fingerprint.

	If RET_KB is not NULL, the keyblock is returned in *RET_KB. This
	should be freed using release_kbnode().

	If RET_KDBHD is not NULL, then the new database handle used to
	conduct the search is returned in *RET_KDBHD. This can be used to
	get subsequent results using keydb_search_next. Note: in this
	case, no advanced filtering is done for subsequent results (e.g.,
	WANT_SECRET and PK->REQ_USAGE are not respected).

	This function returns 0 on success. Otherwise, an error code is
	returned. In particular, GPG_ERR_NO_PUBKEY or GPG_ERR_NO_SECKEY
	(if want_secret is set) is returned if the key is not found. */
	static int
	key_byname (ctrl_t ctrl, GETKEY_CTX *retctx, strlist_t namelist,
	PKT_public_key *pk,
	int want_secret, int include_unusable,
	KBNODE * ret_kb, KEYDB_HANDLE * ret_kdbhd)
	{
	int rc = 0;
	int n;
	- strlist_t r;
	+ strlist_t r, namelist_expanded = NULL, link = NULL;
	GETKEY_CTX ctx;
	KBNODE help_kb = NULL;
	KBNODE found_key = NULL;

	if (retctx)
	{
	/* Reset the returned context in case of error. */
	log_assert (!ret_kdbhd); /* Not allowed because the handle is stored
	in the context. */
	*retctx = NULL;
	}
	if (ret_kdbhd)
	*ret_kdbhd = NULL;

	if (!namelist)
	/* No search terms: iterate over the whole DB. */
	{
	ctx = xmalloc_clear (sizeof *ctx);
	ctx->nitems = 1;
	ctx->items[0].mode = KEYDB_SEARCH_MODE_FIRST;
	if (!include_unusable)
	{
	ctx->items[0].skipfnc = skip_unusable;
	ctx->items[0].skipfncvalue = ctrl;
	}
	}
	else
	{
	+ namelist_expanded = expand_group (namelist);
	+
	+ /* Chain namelist and namelist_expanded */
	+ for (r = namelist; r; r = r->next)
	+ {
	+ if (!r->next)
	+ {
	+ r->next = namelist_expanded;
	+ link = r;
	+ break;
	+ }
	+ }
	+
	/* Build the search context. */
	for (n = 0, r = namelist; r; r = r->next)
	n++;

	/* CTX has space for a single search term at the end. Thus, we
	need to allocate sizeof *CTX plus (n - 1) sizeof
	CTX->ITEMS. */
	ctx = xmalloc_clear (sizeof ctx + (n - 1) sizeof ctx->items);
	ctx->nitems = n;

	for (n = 0, r = namelist; r; r = r->next, n++)
	{
	gpg_error_t err;

	err = classify_user_id (r->d, &ctx->items[n], 1);

	if (ctx->items[n].exact)
	ctx->exact = 1;
	if (err)
	{
	xfree (ctx);
	- return gpg_err_code (err); /* FIXME: remove gpg_err_code. */
	+ rc = gpg_err_code (err); /* FIXME: remove gpg_err_code. */
	+ goto leave;
	}
	if (!include_unusable
	&& ctx->items[n].mode != KEYDB_SEARCH_MODE_SHORT_KID
	&& ctx->items[n].mode != KEYDB_SEARCH_MODE_LONG_KID
	&& ctx->items[n].mode != KEYDB_SEARCH_MODE_FPR)
	{
	ctx->items[n].skipfnc = skip_unusable;
	ctx->items[n].skipfncvalue = ctrl;
	}
	}
	}

	ctx->want_secret = want_secret;
	ctx->kr_handle = keydb_new ();
	if (!ctx->kr_handle)
	{
	rc = gpg_error_from_syserror ();
	getkey_end (ctrl, ctx);
	- return rc;
	+ goto leave;
	}

	if (!ret_kb)
	ret_kb = &help_kb;

	if (pk)
	{
	ctx->req_usage = pk->req_usage;
	}

	rc = lookup (ctrl, ctx, want_secret, ret_kb, &found_key);
	if (!rc && pk)
	{
	pk_from_block (pk, *ret_kb, found_key);
	}

	release_kbnode (help_kb);

	if (retctx) /* Caller wants the context. */
	*retctx = ctx;
	else
	{
	if (ret_kdbhd)
	{
	*ret_kdbhd = ctx->kr_handle;
	ctx->kr_handle = NULL;
	}
	getkey_end (ctrl, ctx);
	}

	+leave:
	+ if (namelist_expanded)
	+ free_strlist(namelist_expanded);
	+ /* Un-chain namelist and namelist_expanded */
	+ if (link)
	+ link->next = NULL;
	return rc;
	}


	/* Find a public key identified by NAME.
	*
	* If name appears to be a valid RFC822 mailbox (i.e., email address)
	* and auto key lookup is enabled (mode != GET_PUBKEY_NO_AKL), then
	* the specified auto key lookup methods (--auto-key-lookup) are used
	* to import the key into the local keyring. Otherwise, just the
	* local keyring is consulted.
	*
	* MODE can be one of:
	* GET_PUBKEY_NORMAL - The standard mode
	* GET_PUBKEY_NO_AKL - The auto key locate functionality is
	* disabled and only the local key ring is
	* considered. Note: the local key ring is
	* consulted even if local is not in the
	* auto-key-locate option list!
	* GET_PUBKEY_NO_LOCAL - Only the auto key locate functionaly is
	* used and no local search is done.
	*
	* If RETCTX is not NULL, then the constructed context is returned in
	* *RETCTX so that getpubkey_next can be used to get subsequent
	* results. In this case, getkey_end() must be used to free the
	* search context. If RETCTX is not NULL, then RET_KDBHD must be
	* NULL.
	*
	* If PK is not NULL, the public key of the first result is returned
	* in *PK. Note: PK->REQ_USAGE must be valid!!! PK->REQ_USAGE is
	* passed through to the lookup function and is a mask of
	* PUBKEY_USAGE_SIG, PUBKEY_USAGE_ENC and PUBKEY_USAGE_CERT. If this
	* is non-zero, only keys with the specified usage will be returned.
	* Note: The self-signed data has already been merged into the public
	* key using merge_selfsigs. Free *PK by calling
	* release_public_key_parts (or, if PK was allocated using xfree, you
	* can use free_public_key, which calls release_public_key_parts(PK)
	* and then xfree(PK)).
	*
	* NAME is a string, which is turned into a search query using
	* classify_user_id.
	*
	* If RET_KEYBLOCK is not NULL, the keyblock is returned in
	* *RET_KEYBLOCK. This should be freed using release_kbnode().
	*
	* If RET_KDBHD is not NULL, then the new database handle used to
	* conduct the search is returned in *RET_KDBHD. This can be used to
	* get subsequent results using keydb_search_next or to modify the
	* returned record. Note: in this case, no advanced filtering is done
	* for subsequent results (e.g., PK->REQ_USAGE is not respected).
	* Unlike RETCTX, this is always returned.
	*
	* If INCLUDE_UNUSABLE is set, then unusable keys (see the
	* documentation for skip_unusable for an exact definition) are
	* skipped unless they are looked up by key id or by fingerprint.
	*
	* This function returns 0 on success. Otherwise, an error code is
	* returned. In particular, GPG_ERR_NO_PUBKEY or GPG_ERR_NO_SECKEY
	* (if want_secret is set) is returned if the key is not found. */
	int
	get_pubkey_byname (ctrl_t ctrl, enum get_pubkey_modes mode,
	GETKEY_CTX * retctx, PKT_public_key * pk,
	const char name, KBNODE ret_keyblock,
	KEYDB_HANDLE * ret_kdbhd, int include_unusable)
	{
	int rc;
	strlist_t namelist = NULL;
	struct akl *akl;
	int is_mbox;
	int nodefault = 0;
	int anylocalfirst = 0;
	int mechanism_type = AKL_NODEFAULT;

	/* If RETCTX is not NULL, then RET_KDBHD must be NULL. */
	log_assert (retctx == NULL \|\| ret_kdbhd == NULL);

	if (retctx)
	*retctx = NULL;

	/* Does NAME appear to be a mailbox (mail address)? */
	is_mbox = is_valid_mailbox (name);

	/* The auto-key-locate feature works as follows: there are a number
	* of methods to look up keys. By default, the local keyring is
	* tried first. Then, each method listed in the --auto-key-locate is
	* tried in the order it appears.
	*
	* This can be changed as follows:
	*
	* - if nodefault appears anywhere in the list of options, then
	* the local keyring is not tried first, or,
	*
	* - if local appears anywhere in the list of options, then the
	* local keyring is not tried first, but in the order in which
	* it was listed in the --auto-key-locate option.
	*
	* Note: we only save the search context in RETCTX if the local
	* method is the first method tried (either explicitly or
	* implicitly). */
	if (mode == GET_PUBKEY_NO_LOCAL)
	nodefault = 1; /* Auto-key-locate but ignore "local". */
	else if (mode != GET_PUBKEY_NO_AKL)
	{
	/* auto-key-locate is enabled. */

	/* nodefault is true if "nodefault" or "local" appear. */
	for (akl = opt.auto_key_locate; akl; akl = akl->next)
	if (akl->type == AKL_NODEFAULT \|\| akl->type == AKL_LOCAL)
	{
	nodefault = 1;
	break;
	}
	/* anylocalfirst is true if "local" appears before any other
	search methods (except "nodefault"). */
	for (akl = opt.auto_key_locate; akl; akl = akl->next)
	if (akl->type != AKL_NODEFAULT)
	{
	if (akl->type == AKL_LOCAL)
	anylocalfirst = 1;
	break;
	}
	}

	if (!nodefault)
	{
	/* "nodefault" didn't occur. Thus, "local" is implicitly the
	* first method to try. */
	anylocalfirst = 1;
	}

	if (mode == GET_PUBKEY_NO_LOCAL)
	{
	/* Force using the AKL. If IS_MBOX is not set this is the final
	* error code. */
	rc = GPG_ERR_NO_PUBKEY;
	}
	else if (nodefault && is_mbox)
	{
	/* Either "nodefault" or "local" (explicitly) appeared in the
	* auto key locate list and NAME appears to be an email address.
	* Don't try the local keyring. */
	rc = GPG_ERR_NO_PUBKEY;
	}
	else
	{
	/* Either "nodefault" and "local" don't appear in the auto key
	* locate list (in which case we try the local keyring first) or
	* NAME does not appear to be an email address (in which case we
	* only try the local keyring). In this case, lookup NAME in
	* the local keyring. */
	add_to_strlist (&namelist, name);
	rc = key_byname (ctrl, retctx, namelist, pk, 0,
	include_unusable, ret_keyblock, ret_kdbhd);
	}

	/* If the requested name resembles a valid mailbox and automatic
	retrieval has been enabled, we try to import the key. */
	if (gpg_err_code (rc) == GPG_ERR_NO_PUBKEY
	&& mode != GET_PUBKEY_NO_AKL
	&& is_mbox)
	{
	/* NAME wasn't present in the local keyring (or we didn't try
	* the local keyring). Since the auto key locate feature is
	* enabled and NAME appears to be an email address, try the auto
	* locate feature. */
	for (akl = opt.auto_key_locate; akl; akl = akl->next)
	{
	unsigned char *fpr = NULL;
	size_t fpr_len;
	int did_akl_local = 0;
	int no_fingerprint = 0;
	const char *mechanism_string = "?";

	mechanism_type = akl->type;
	switch (mechanism_type)
	{
	case AKL_NODEFAULT:
	/* This is a dummy mechanism. */
	mechanism_string = "";
	rc = GPG_ERR_NO_PUBKEY;
	break;

	case AKL_LOCAL:
	if (mode == GET_PUBKEY_NO_LOCAL)
	{
	mechanism_string = "";
	rc = GPG_ERR_NO_PUBKEY;
	}
	else
	{
	mechanism_string = "Local";
	did_akl_local = 1;
	if (retctx)
	{
	getkey_end (ctrl, *retctx);
	*retctx = NULL;
	}
	add_to_strlist (&namelist, name);
	rc = key_byname (ctrl, anylocalfirst ? retctx : NULL,
	namelist, pk, 0,
	include_unusable, ret_keyblock, ret_kdbhd);
	}
	break;

	case AKL_CERT:
	mechanism_string = "DNS CERT";
	glo_ctrl.in_auto_key_retrieve++;
	rc = keyserver_import_cert (ctrl, name, 0, &fpr, &fpr_len);
	glo_ctrl.in_auto_key_retrieve--;
	break;

	case AKL_PKA:
	mechanism_string = "PKA";
	glo_ctrl.in_auto_key_retrieve++;
	rc = keyserver_import_pka (ctrl, name, &fpr, &fpr_len);
	glo_ctrl.in_auto_key_retrieve--;
	break;

	case AKL_DANE:
	mechanism_string = "DANE";
	glo_ctrl.in_auto_key_retrieve++;
	rc = keyserver_import_cert (ctrl, name, 1, &fpr, &fpr_len);
	glo_ctrl.in_auto_key_retrieve--;
	break;

	case AKL_WKD:
	mechanism_string = "WKD";
	glo_ctrl.in_auto_key_retrieve++;
	rc = keyserver_import_wkd (ctrl, name, 0, &fpr, &fpr_len);
	glo_ctrl.in_auto_key_retrieve--;
	break;

	case AKL_LDAP:
	mechanism_string = "LDAP";
	glo_ctrl.in_auto_key_retrieve++;
	rc = keyserver_import_ldap (ctrl, name, &fpr, &fpr_len);
	glo_ctrl.in_auto_key_retrieve--;
	break;

	case AKL_KEYSERVER:
	/* Strictly speaking, we don't need to only use a valid
	* mailbox for the getname search, but it helps cut down
	* on the problem of searching for something like "john"
	* and getting a whole lot of keys back. */
	if (keyserver_any_configured (ctrl))
	{
	mechanism_string = "keyserver";
	glo_ctrl.in_auto_key_retrieve++;
	rc = keyserver_import_name (ctrl, name, &fpr, &fpr_len,
	opt.keyserver);
	glo_ctrl.in_auto_key_retrieve--;
	}
	else
	{
	mechanism_string = "Unconfigured keyserver";
	rc = GPG_ERR_NO_PUBKEY;
	}
	break;

	case AKL_SPEC:
	{
	struct keyserver_spec *keyserver;

	mechanism_string = akl->spec->uri;
	keyserver = keyserver_match (akl->spec);
	glo_ctrl.in_auto_key_retrieve++;
	rc = keyserver_import_name (ctrl,
	name, &fpr, &fpr_len, keyserver);
	glo_ctrl.in_auto_key_retrieve--;
	}
	break;
	}

	/* Use the fingerprint of the key that we actually fetched.
	* This helps prevent problems where the key that we fetched
	* doesn't have the same name that we used to fetch it. In
	* the case of CERT and PKA, this is an actual security
	* requirement as the URL might point to a key put in by an
	* attacker. By forcing the use of the fingerprint, we
	* won't use the attacker's key here. */
	if (!rc && fpr)
	{
	char fpr_string[MAX_FINGERPRINT_LEN * 2 + 1];

	log_assert (fpr_len <= MAX_FINGERPRINT_LEN);

	free_strlist (namelist);
	namelist = NULL;

	bin2hex (fpr, fpr_len, fpr_string);

	if (opt.verbose)
	log_info ("auto-key-locate found fingerprint %s\n",
	fpr_string);

	add_to_strlist (&namelist, fpr_string);
	}
	else if (!rc && !fpr && !did_akl_local)
	{ /* The acquisition method said no failure occurred, but
	* it didn't return a fingerprint. That's a failure. */
	no_fingerprint = 1;
	rc = GPG_ERR_NO_PUBKEY;
	}
	xfree (fpr);
	fpr = NULL;

	if (!rc && !did_akl_local)
	{ /* There was no error and we didn't do a local lookup.
	* This means that we imported a key into the local
	* keyring. Try to read the imported key from the
	* keyring. */
	if (retctx)
	{
	getkey_end (ctrl, *retctx);
	*retctx = NULL;
	}
	rc = key_byname (ctrl, anylocalfirst ? retctx : NULL,
	namelist, pk, 0,
	include_unusable, ret_keyblock, ret_kdbhd);
	}
	if (!rc)
	{
	/* Key found. */
	if (opt.verbose)
	log_info (_("automatically retrieved '%s' via %s\n"),
	name, mechanism_string);
	break;
	}
	if ((gpg_err_code (rc) != GPG_ERR_NO_PUBKEY
	\|\| opt.verbose \|\| no_fingerprint) && *mechanism_string)
	log_info (_("error retrieving '%s' via %s: %s\n"),
	name, mechanism_string,
	no_fingerprint ? _("No fingerprint") : gpg_strerror (rc));
	}
	}

	if (rc && retctx)
	{
	getkey_end (ctrl, *retctx);
	*retctx = NULL;
	}

	if (retctx && *retctx)
	{
	log_assert (!(*retctx)->extra_list);
	(*retctx)->extra_list = namelist;
	(*retctx)->found_via_akl = mechanism_type;
	}
	else
	free_strlist (namelist);

	return rc;
	}




	/* Comparison machinery for get_best_pubkey_byname. */

	/* First we have a struct to cache computed information about the key
	* in question. */
	struct pubkey_cmp_cookie
	{
	int valid; /* Is this cookie valid? */
	PKT_public_key key; /* The key. */
	PKT_user_id uid; / The matching UID packet. */
	unsigned int validity; /* Computed validity of (KEY, UID). */
	u32 creation_time; /* Creation time of the newest subkey
	capable of encryption. */
	};


	/* Then we have a series of helper functions. */
	static int
	key_is_ok (const PKT_public_key *key)
	{
	return (! key->has_expired && ! key->flags.revoked
	&& key->flags.valid && ! key->flags.disabled);
	}


	static int
	uid_is_ok (const PKT_public_key key, const PKT_user_id uid)
	{
	return key_is_ok (key) && ! uid->flags.revoked;
	}


	static int
	subkey_is_ok (const PKT_public_key *sub)
	{
	return ! sub->flags.revoked && sub->flags.valid && ! sub->flags.disabled;
	}

	/* Return true if KEYBLOCK has only expired encryption subkyes. Note
	* that the function returns false if the key has no encryption
	* subkeys at all or the subkeys are revoked. */
	static int
	only_expired_enc_subkeys (kbnode_t keyblock)
	{
	kbnode_t node;
	PKT_public_key *sub;
	int any = 0;

	for (node = find_next_kbnode (keyblock, PKT_PUBLIC_SUBKEY);
	node; node = find_next_kbnode (node, PKT_PUBLIC_SUBKEY))
	{
	sub = node->pkt->pkt.public_key;

	if (!(sub->pubkey_usage & PUBKEY_USAGE_ENC))
	continue;

	if (!subkey_is_ok (sub))
	continue;

	any = 1;
	if (!sub->has_expired)
	return 0;
	}

	return any? 1 : 0;
	}

	/* Finally this function compares a NEW key to the former candidate
	* OLD. Returns < 0 if the old key is worse, > 0 if the old key is
	* better, == 0 if it is a tie. */
	static int
	pubkey_cmp (ctrl_t ctrl, const char name, struct pubkey_cmp_cookie old,
	struct pubkey_cmp_cookie *new, KBNODE new_keyblock)
	{
	kbnode_t n;

	new->creation_time = 0;
	for (n = find_next_kbnode (new_keyblock, PKT_PUBLIC_SUBKEY);
	n; n = find_next_kbnode (n, PKT_PUBLIC_SUBKEY))
	{
	PKT_public_key *sub = n->pkt->pkt.public_key;

	if ((sub->pubkey_usage & PUBKEY_USAGE_ENC) == 0)
	continue;

	if (! subkey_is_ok (sub))
	continue;

	if (sub->timestamp > new->creation_time)
	new->creation_time = sub->timestamp;
	}

	for (n = find_next_kbnode (new_keyblock, PKT_USER_ID);
	n; n = find_next_kbnode (n, PKT_USER_ID))
	{
	PKT_user_id *uid = n->pkt->pkt.user_id;
	char *mbox = mailbox_from_userid (uid->name, 0);
	int match = mbox ? strcasecmp (name, mbox) == 0 : 0;

	xfree (mbox);
	if (! match)
	continue;

	new->uid = scopy_user_id (uid);
	new->validity =
	get_validity (ctrl, new_keyblock, &new->key, uid, NULL, 0) & TRUST_MASK;
	new->valid = 1;

	if (! old->valid)
	return -1; /* No OLD key. */

	if (! uid_is_ok (&old->key, old->uid) && uid_is_ok (&new->key, uid))
	return -1; /* Validity of the NEW key is better. */

	if (old->validity < new->validity)
	return -1; /* Validity of the NEW key is better. */

	if (old->validity == new->validity && uid_is_ok (&new->key, uid)
	&& old->creation_time < new->creation_time)
	return -1; /* Both keys are of the same validity, but the
	NEW key is newer. */
	}

	/* Stick with the OLD key. */
	return 1;
	}


	/* This function works like get_pubkey_byname, but if the name
	* resembles a mail address, the results are ranked and only the best
	* result is returned. */
	gpg_error_t
	get_best_pubkey_byname (ctrl_t ctrl, enum get_pubkey_modes mode,
	GETKEY_CTX retctx, PKT_public_key pk,
	const char name, KBNODE ret_keyblock,
	int include_unusable)
	{
	gpg_error_t err;
	struct getkey_ctx_s *ctx = NULL;
	int is_mbox = is_valid_mailbox (name);
	int wkd_tried = 0;

	if (retctx)
	*retctx = NULL;

	start_over:
	if (ctx) /* Clear in case of a start over. */
	{
	if (ret_keyblock)
	{
	release_kbnode (*ret_keyblock);
	*ret_keyblock = NULL;
	}
	getkey_end (ctrl, ctx);
	ctx = NULL;
	}
	err = get_pubkey_byname (ctrl, mode,
	&ctx, pk, name, ret_keyblock,
	NULL, include_unusable);
	if (err)
	{
	getkey_end (ctrl, ctx);
	return err;
	}

	/* If the keyblock was retrieved from the local database and the key
	* has expired, do further checks. However, we can do this only if
	* the caller requested a keyblock. */
	if (is_mbox && ctx && ctx->found_via_akl == AKL_LOCAL && ret_keyblock)
	{
	u32 now = make_timestamp ();
	PKT_public_key pk2 = (ret_keyblock)->pkt->pkt.public_key;
	int found;

	/* If the key has expired and its origin was the WKD then try to
	* get a fresh key from the WKD. We also try this if the key
	* has any only expired encryption subkeys. In case we checked
	* for a fresh copy in the last 3 hours we won't do that again.
	* Unfortunately that does not yet work because KEYUPDATE is
	* only updated during import iff the key has actually changed
	* (see import.c:import_one). */
	if (!wkd_tried && pk2->keyorg == KEYORG_WKD
	&& (pk2->keyupdate + 3*3600) < now
	&& (pk2->has_expired \|\| only_expired_enc_subkeys (*ret_keyblock)))
	{
	if (opt.verbose)
	log_info (_("checking for a fresh copy of an expired key via %s\n"),
	"WKD");
	wkd_tried = 1;
	glo_ctrl.in_auto_key_retrieve++;
	found = !keyserver_import_wkd (ctrl, name, 0, NULL, NULL);
	glo_ctrl.in_auto_key_retrieve--;
	if (found)
	goto start_over;
	}
	}

	if (is_mbox && ctx)
	{
	/* Rank results and return only the most relevant key. */
	struct pubkey_cmp_cookie best = { 0 };
	struct pubkey_cmp_cookie new = { 0 };
	kbnode_t new_keyblock;

	while (getkey_next (ctrl, ctx, &new.key, &new_keyblock) == 0)
	{
	int diff = pubkey_cmp (ctrl, name, &best, &new, new_keyblock);
	release_kbnode (new_keyblock);
	if (diff < 0)
	{
	/* New key is better. */
	release_public_key_parts (&best.key);
	free_user_id (best.uid);
	best = new;
	}
	else if (diff > 0)
	{
	/* Old key is better. */
	release_public_key_parts (&new.key);
	free_user_id (new.uid);
	}
	else
	{
	/* A tie. Keep the old key. */
	release_public_key_parts (&new.key);
	free_user_id (new.uid);
	}
	new.uid = NULL;
	}
	getkey_end (ctrl, ctx);
	ctx = NULL;
	free_user_id (best.uid);
	best.uid = NULL;

	if (best.valid)
	{
	if (retctx \|\| ret_keyblock)
	{
	ctx = xtrycalloc (1, sizeof **retctx);
	if (! ctx)
	err = gpg_error_from_syserror ();
	else
	{
	ctx->kr_handle = keydb_new ();
	if (! ctx->kr_handle)
	{
	err = gpg_error_from_syserror ();
	xfree (ctx);
	ctx = NULL;
	if (retctx)
	*retctx = NULL;
	}
	else
	{
	u32 *keyid = pk_keyid (&best.key);
	ctx->exact = 1;
	ctx->nitems = 1;
	ctx->items[0].mode = KEYDB_SEARCH_MODE_LONG_KID;
	ctx->items[0].u.kid[0] = keyid[0];
	ctx->items[0].u.kid[1] = keyid[1];

	if (ret_keyblock)
	{
	release_kbnode (*ret_keyblock);
	*ret_keyblock = NULL;
	err = getkey_next (ctrl, ctx, NULL, ret_keyblock);
	}
	}
	}
	}

	if (pk)
	*pk = best.key;
	else
	release_public_key_parts (&best.key);
	}
	}

	if (err && ctx)
	{
	getkey_end (ctrl, ctx);
	ctx = NULL;
	}

	if (retctx && ctx)
	*retctx = ctx;
	else
	getkey_end (ctrl, ctx);

	return err;
	}



	/* Get a public key from a file.
	*
	* PK is the buffer to store the key. The caller needs to make sure
	* that PK->REQ_USAGE is valid. PK->REQ_USAGE is passed through to
	* the lookup function and is a mask of PUBKEY_USAGE_SIG,
	* PUBKEY_USAGE_ENC and PUBKEY_USAGE_CERT. If this is non-zero, only
	* keys with the specified usage will be returned.
	*
	* FNAME is the file name. That file should contain exactly one
	* keyblock.
	*
	* This function returns 0 on success. Otherwise, an error code is
	* returned. In particular, GPG_ERR_NO_PUBKEY is returned if the key
	* is not found.
	*
	* The self-signed data has already been merged into the public key
	* using merge_selfsigs. The caller must release the content of PK by
	* calling release_public_key_parts (or, if PK was malloced, using
	* free_public_key).
	*/
	gpg_error_t
	get_pubkey_fromfile (ctrl_t ctrl, PKT_public_key pk, const char fname)
	{
	gpg_error_t err;
	kbnode_t keyblock;
	kbnode_t found_key;
	unsigned int infoflags;

	err = read_key_from_file (ctrl, fname, &keyblock);
	if (!err)
	{
	/* Warning: node flag bits 0 and 1 should be preserved by
	* merge_selfsigs. FIXME: Check whether this still holds. */
	merge_selfsigs (ctrl, keyblock);
	found_key = finish_lookup (keyblock, pk->req_usage, 0, 0, &infoflags);
	print_status_key_considered (keyblock, infoflags);
	if (found_key)
	pk_from_block (pk, keyblock, found_key);
	else
	err = gpg_error (GPG_ERR_UNUSABLE_PUBKEY);
	}

	release_kbnode (keyblock);
	return err;
	}


	/* Lookup a key with the specified fingerprint.
	*
	* If PK is not NULL, the public key of the first result is returned
	* in *PK. Note: this function does an exact search and thus the
	* returned public key may be a subkey rather than the primary key.
	* Note: The self-signed data has already been merged into the public
	* key using merge_selfsigs. Free *PK by calling
	* release_public_key_parts (or, if PK was allocated using xfree, you
	* can use free_public_key, which calls release_public_key_parts(PK)
	* and then xfree(PK)).
	*
	* If PK->REQ_USAGE is set, it is used to filter the search results.
	* (Thus, if PK is not NULL, PK->REQ_USAGE must be valid!!!) See the
	* documentation for finish_lookup to understand exactly how this is
	* used.
	*
	* If R_KEYBLOCK is not NULL, then the first result's keyblock is
	* returned in *R_KEYBLOCK. This should be freed using
	* release_kbnode().
	*
	* FPRINT is a byte array whose contents is the fingerprint to use as
	* the search term. FPRINT_LEN specifies the length of the
	* fingerprint (in bytes). Currently, only 16, 20, and 32-byte
	* fingerprints are supported.
	*
	* FIXME: We should replace this with the _byname function. This can
	* be done by creating a userID conforming to the unified fingerprint
	* style. */
	int
	get_pubkey_byfprint (ctrl_t ctrl, PKT_public_key pk, kbnode_t r_keyblock,
	const byte * fprint, size_t fprint_len)
	{
	int rc;

	if (r_keyblock)
	*r_keyblock = NULL;

	if (fprint_len == 32 \|\| fprint_len == 20 \|\| fprint_len == 16)
	{
	struct getkey_ctx_s ctx;
	KBNODE kb = NULL;
	KBNODE found_key = NULL;

	memset (&ctx, 0, sizeof ctx);
	ctx.exact = 1;
	ctx.not_allocated = 1;
	/* FIXME: We should get the handle from the cache like we do in
	* get_pubkey. */
	ctx.kr_handle = keydb_new ();
	if (!ctx.kr_handle)
	return gpg_error_from_syserror ();

	ctx.nitems = 1;
	ctx.items[0].mode = KEYDB_SEARCH_MODE_FPR;
	memcpy (ctx.items[0].u.fpr, fprint, fprint_len);
	ctx.items[0].fprlen = fprint_len;
	if (pk)
	ctx.req_usage = pk->req_usage;
	rc = lookup (ctrl, &ctx, 0, &kb, &found_key);
	if (!rc && pk)
	pk_from_block (pk, kb, found_key);
	if (!rc && r_keyblock)
	{
	*r_keyblock = kb;
	kb = NULL;
	}
	release_kbnode (kb);
	getkey_end (ctrl, &ctx);
	}
	else
	rc = GPG_ERR_GENERAL; /* Oops */
	return rc;
	}


	/* This function is similar to get_pubkey_byfprint, but it doesn't
	* merge the self-signed data into the public key and subkeys or into
	* the user ids. It also doesn't add the key to the user id cache.
	* Further, this function ignores PK->REQ_USAGE.
	*
	* This function is intended to avoid recursion and, as such, should
	* only be used in very specific situations.
	*
	* Like get_pubkey_byfprint, PK may be NULL. In that case, this
	* function effectively just checks for the existence of the key. */
	gpg_error_t
	get_pubkey_byfprint_fast (PKT_public_key * pk,
	const byte * fprint, size_t fprint_len)
	{
	gpg_error_t err;
	KBNODE keyblock;

	err = get_keyblock_byfprint_fast (&keyblock, NULL, fprint, fprint_len, 0);
	if (!err)
	{
	if (pk)
	copy_public_key (pk, keyblock->pkt->pkt.public_key);
	release_kbnode (keyblock);
	}

	return err;
	}


	/* This function is similar to get_pubkey_byfprint_fast but returns a
	* keydb handle at R_HD and the keyblock at R_KEYBLOCK. R_KEYBLOCK or
	* R_HD may be NULL. If LOCK is set the handle has been opend in
	* locked mode and keydb_disable_caching () has been called. On error
	* R_KEYBLOCK is set to NULL but R_HD must be released by the caller;
	* it may have a value of NULL, though. This allows to do an insert
	* operation on a locked keydb handle. */
	gpg_error_t
	get_keyblock_byfprint_fast (kbnode_t r_keyblock, KEYDB_HANDLE r_hd,
	const byte *fprint, size_t fprint_len, int lock)
	{
	gpg_error_t err;
	KEYDB_HANDLE hd;
	kbnode_t keyblock;
	byte fprbuf[MAX_FINGERPRINT_LEN];
	int i;

	if (r_keyblock)
	*r_keyblock = NULL;
	if (r_hd)
	*r_hd = NULL;

	for (i = 0; i < MAX_FINGERPRINT_LEN && i < fprint_len; i++)
	fprbuf[i] = fprint[i];

	hd = keydb_new ();
	if (!hd)
	return gpg_error_from_syserror ();

	if (lock)
	{
	err = keydb_lock (hd);
	if (err)
	{
	/* If locking did not work, we better don't return a handle
	* at all - there was a reason that locking has been
	* requested. */
	keydb_release (hd);
	return err;
	}
	keydb_disable_caching (hd);
	}

	/* Fo all other errors we return the handle. */
	if (r_hd)
	*r_hd = hd;

	err = keydb_search_fpr (hd, fprbuf, fprint_len);
	if (gpg_err_code (err) == GPG_ERR_NOT_FOUND)
	{
	if (!r_hd)
	keydb_release (hd);
	return gpg_error (GPG_ERR_NO_PUBKEY);
	}
	err = keydb_get_keyblock (hd, &keyblock);
	if (err)
	{
	log_error ("keydb_get_keyblock failed: %s\n", gpg_strerror (err));
	if (!r_hd)
	keydb_release (hd);
	return gpg_error (GPG_ERR_NO_PUBKEY);
	}

	log_assert (keyblock->pkt->pkttype == PKT_PUBLIC_KEY
	\|\| keyblock->pkt->pkttype == PKT_PUBLIC_SUBKEY);

	/* Not caching key here since it won't have all of the fields
	properly set. */

	if (r_keyblock)
	*r_keyblock = keyblock;
	else
	release_kbnode (keyblock);

	if (!r_hd)
	keydb_release (hd);

	return 0;
	}


	const char *
	parse_def_secret_key (ctrl_t ctrl)
	{
	KEYDB_HANDLE hd = NULL;
	strlist_t t;
	static int warned;

	for (t = opt.def_secret_key; t; t = t->next)
	{
	gpg_error_t err;
	KEYDB_SEARCH_DESC desc;
	KBNODE kb;
	KBNODE node;

	err = classify_user_id (t->d, &desc, 1);
	if (err)
	{
	log_error (_("secret key \"%s\" not found: %s\n"),
	t->d, gpg_strerror (err));
	if (!opt.quiet)
	log_info (_("(check argument of option '%s')\n"), "--default-key");
	continue;
	}

	if (! hd)
	{
	hd = keydb_new ();
	if (!hd)
	return NULL;
	}
	else
	keydb_search_reset (hd);


	err = keydb_search (hd, &desc, 1, NULL);
	if (gpg_err_code (err) == GPG_ERR_NOT_FOUND)
	continue;

	if (err)
	{
	log_error (_("key \"%s\" not found: %s\n"), t->d, gpg_strerror (err));
	t = NULL;
	break;
	}

	err = keydb_get_keyblock (hd, &kb);
	if (err)
	{
	log_error (_("error reading keyblock: %s\n"),
	gpg_strerror (err));
	continue;
	}

	merge_selfsigs (ctrl, kb);

	err = gpg_error (GPG_ERR_NO_SECKEY);
	node = kb;
	do
	{
	PKT_public_key *pk = node->pkt->pkt.public_key;

	/* Check that the key has the signing capability. */
	if (! (pk->pubkey_usage & PUBKEY_USAGE_SIG))
	continue;

	/* Check if the key is valid. */
	if (pk->flags.revoked)
	{
	if (DBG_LOOKUP)
	log_debug ("not using %s as default key, %s",
	keystr_from_pk (pk), "revoked");
	continue;
	}
	if (pk->has_expired)
	{
	if (DBG_LOOKUP)
	log_debug ("not using %s as default key, %s",
	keystr_from_pk (pk), "expired");
	continue;
	}
	if (pk_is_disabled (pk))
	{
	if (DBG_LOOKUP)
	log_debug ("not using %s as default key, %s",
	keystr_from_pk (pk), "disabled");
	continue;
	}

	err = agent_probe_secret_key (ctrl, pk);
	if (! err)
	/* This is a valid key. */
	break;
	}
	while ((node = find_next_kbnode (node, PKT_PUBLIC_SUBKEY)));

	release_kbnode (kb);
	if (err)
	{
	if (! warned && ! opt.quiet)
	{
	log_info (_("Warning: not using '%s' as default key: %s\n"),
	t->d, gpg_strerror (GPG_ERR_NO_SECKEY));
	print_reported_error (err, GPG_ERR_NO_SECKEY);
	}
	}
	else
	{
	if (! warned && ! opt.quiet)
	log_info (_("using \"%s\" as default secret key for signing\n"),
	t->d);
	break;
	}
	}

	if (! warned && opt.def_secret_key && ! t)
	log_info (_("all values passed to '%s' ignored\n"),
	"--default-key");

	warned = 1;

	if (hd)
	keydb_release (hd);

	if (t)
	return t->d;
	return NULL;
	}


	/* Look up a secret key.
	*
	* If PK is not NULL, the public key of the first result is returned
	* in *PK. Note: PK->REQ_USAGE must be valid!!! If PK->REQ_USAGE is
	* set, it is used to filter the search results. See the
	* documentation for finish_lookup to understand exactly how this is
	* used. Note: The self-signed data has already been merged into the
	* public key using merge_selfsigs. Free *PK by calling
	* release_public_key_parts (or, if PK was allocated using xfree, you
	* can use free_public_key, which calls release_public_key_parts(PK)
	* and then xfree(PK)).
	*
	* If --default-key was set, then the specified key is looked up. (In
	* this case, the default key is returned even if it is considered
	* unusable. See the documentation for skip_unusable for exactly what
	* this means.)
	*
	* Otherwise, this initiates a DB scan that returns all keys that are
	* usable (see previous paragraph for exactly what usable means) and
	* for which a secret key is available.
	*
	* This function returns the first match. Additional results can be
	* returned using getkey_next. */
	gpg_error_t
	get_seckey_default (ctrl_t ctrl, PKT_public_key *pk)
	{
	gpg_error_t err;
	strlist_t namelist = NULL;
	int include_unusable = 1;


	const char *def_secret_key = parse_def_secret_key (ctrl);
	if (def_secret_key)
	add_to_strlist (&namelist, def_secret_key);
	else
	include_unusable = 0;

	err = key_byname (ctrl, NULL, namelist, pk, 1, include_unusable, NULL, NULL);

	free_strlist (namelist);

	return err;
	}



	/* Search for keys matching some criteria.
	*
	* If RETCTX is not NULL, then the constructed context is returned in
	* *RETCTX so that getpubkey_next can be used to get subsequent
	* results. In this case, getkey_end() must be used to free the
	* search context. If RETCTX is not NULL, then RET_KDBHD must be
	* NULL.
	*
	* If PK is not NULL, the public key of the first result is returned
	* in *PK. Note: PK->REQ_USAGE must be valid!!! If PK->REQ_USAGE is
	* set, it is used to filter the search results. See the
	* documentation for finish_lookup to understand exactly how this is
	* used. Note: The self-signed data has already been merged into the
	* public key using merge_selfsigs. Free *PK by calling
	* release_public_key_parts (or, if PK was allocated using xfree, you
	* can use free_public_key, which calls release_public_key_parts(PK)
	* and then xfree(PK)).
	*
	* If NAMES is not NULL, then a search query is constructed using
	* classify_user_id on each of the strings in the list. (Recall: the
	* database does an OR of the terms, not an AND.) If NAMES is
	* NULL, then all results are returned.
	*
	* If WANT_SECRET is set, then only keys with an available secret key
	* (either locally or via key registered on a smartcard) are returned.
	*
	* This function does not skip unusable keys (see the documentation
	* for skip_unusable for an exact definition).
	*
	* If RET_KEYBLOCK is not NULL, the keyblock is returned in
	* *RET_KEYBLOCK. This should be freed using release_kbnode().
	*
	* This function returns 0 on success. Otherwise, an error code is
	* returned. In particular, GPG_ERR_NO_PUBKEY or GPG_ERR_NO_SECKEY
	* (if want_secret is set) is returned if the key is not found. */
	gpg_error_t
	getkey_bynames (ctrl_t ctrl, getkey_ctx_t retctx, PKT_public_key pk,
	strlist_t names, int want_secret, kbnode_t *ret_keyblock)
	{
	return key_byname (ctrl, retctx, names, pk, want_secret, 1,
	ret_keyblock, NULL);
	}


	/* Search for one key matching some criteria.
	*
	* If RETCTX is not NULL, then the constructed context is returned in
	* *RETCTX so that getpubkey_next can be used to get subsequent
	* results. In this case, getkey_end() must be used to free the
	* search context. If RETCTX is not NULL, then RET_KDBHD must be
	* NULL.
	*
	* If PK is not NULL, the public key of the first result is returned
	* in *PK. Note: PK->REQ_USAGE must be valid!!! If PK->REQ_USAGE is
	* set, it is used to filter the search results. See the
	* documentation for finish_lookup to understand exactly how this is
	* used. Note: The self-signed data has already been merged into the
	* public key using merge_selfsigs. Free *PK by calling
	* release_public_key_parts (or, if PK was allocated using xfree, you
	* can use free_public_key, which calls release_public_key_parts(PK)
	* and then xfree(PK)).
	*
	* If NAME is not NULL, then a search query is constructed using
	* classify_user_id on the string. In this case, even unusable keys
	* (see the documentation for skip_unusable for an exact definition of
	* unusable) are returned. Otherwise, if --default-key was set, then
	* that key is returned (even if it is unusable). If neither of these
	* conditions holds, then the first usable key is returned.
	*
	* If WANT_SECRET is set, then only keys with an available secret key
	* (either locally or via key registered on a smartcard) are returned.
	*
	* This function does not skip unusable keys (see the documentation
	* for skip_unusable for an exact definition).
	*
	* If RET_KEYBLOCK is not NULL, the keyblock is returned in
	* *RET_KEYBLOCK. This should be freed using release_kbnode().
	*
	* This function returns 0 on success. Otherwise, an error code is
	* returned. In particular, GPG_ERR_NO_PUBKEY or GPG_ERR_NO_SECKEY
	* (if want_secret is set) is returned if the key is not found.
	*
	* FIXME: We also have the get_pubkey_byname function which has a
	* different semantic. Should be merged with this one. */
	gpg_error_t
	getkey_byname (ctrl_t ctrl, getkey_ctx_t retctx, PKT_public_key pk,
	const char name, int want_secret, kbnode_t ret_keyblock)
	{
	gpg_error_t err;
	strlist_t namelist = NULL;
	int with_unusable = 1;
	const char *def_secret_key = NULL;

	if (want_secret && !name)
	def_secret_key = parse_def_secret_key (ctrl);

	if (want_secret && !name && def_secret_key)
	add_to_strlist (&namelist, def_secret_key);
	else if (name)
	add_to_strlist (&namelist, name);
	else
	with_unusable = 0;

	err = key_byname (ctrl, retctx, namelist, pk, want_secret, with_unusable,
	ret_keyblock, NULL);

	/* FIXME: Check that we really return GPG_ERR_NO_SECKEY if
	WANT_SECRET has been used. */

	free_strlist (namelist);

	return err;
	}


	/* Return the next search result.
	*
	* If PK is not NULL, the public key of the next result is returned in
	* *PK. Note: The self-signed data has already been merged into the
	* public key using merge_selfsigs. Free *PK by calling
	* release_public_key_parts (or, if PK was allocated using xmalloc, you
	* can use free_public_key, which calls release_public_key_parts(PK)
	* and then xfree(PK)).
	*
	* RET_KEYBLOCK can be given as NULL; if it is not NULL it the entire
	* found keyblock is returned which must be released with
	* release_kbnode. If the function returns an error NULL is stored at
	* RET_KEYBLOCK.
	*
	* The self-signed data has already been merged into the public key
	* using merge_selfsigs. */
	gpg_error_t
	getkey_next (ctrl_t ctrl, getkey_ctx_t ctx,
	PKT_public_key pk, kbnode_t ret_keyblock)
	{
	int rc; /* Fixme: Make sure this is proper gpg_error */
	KBNODE keyblock = NULL;
	KBNODE found_key = NULL;

	/* We need to disable the caching so that for an exact key search we
	won't get the result back from the cache and thus end up in an
	endless loop. The endless loop can occur, because the cache is
	used without respecting the current file pointer! */
	keydb_disable_caching (ctx->kr_handle);

	/* FOUND_KEY is only valid as long as RET_KEYBLOCK is. If the
	* caller wants PK, but not RET_KEYBLOCK, we need hand in our own
	* keyblock. */
	if (pk && ret_keyblock == NULL)
	ret_keyblock = &keyblock;

	rc = lookup (ctrl, ctx, ctx->want_secret,
	ret_keyblock, pk ? &found_key : NULL);
	if (!rc && pk)
	{
	log_assert (found_key);
	pk_from_block (pk, NULL, found_key);
	release_kbnode (keyblock);
	}

	return rc;
	}


	/* Release any resources used by a key listing context. This must be
	* called on the context returned by, e.g., getkey_byname. */
	void
	getkey_end (ctrl_t ctrl, getkey_ctx_t ctx)
	{
	if (ctx)
	{
	#ifdef HAVE_W32_SYSTEM

	/* FIXME: This creates a big regression for Windows because the
	* keyring is only released after the global ctrl is released.
	* So if an operation does a getkey and then tries to modify the
	* keyring it will fail on Windows with a sharing violation. We
	* need to modify all keyring write operations to also take the
	* ctrl and close the cached_getkey_kdb handle to make writing
	* work. See: GnuPG-bug-id: 3097 */
	(void)ctrl;
	keydb_release (ctx->kr_handle);

	#else /!HAVE_W32_SYSTEM/

	if (ctrl && !ctrl->cached_getkey_kdb)
	ctrl->cached_getkey_kdb = ctx->kr_handle;
	else
	keydb_release (ctx->kr_handle);

	#endif /!HAVE_W32_SYSTEM/

	free_strlist (ctx->extra_list);
	if (!ctx->not_allocated)
	xfree (ctx);
	}
	}



	/************************************************
	*********** Merging stuff ******************
	************************************************/

	/* Set the mainkey_id fields for all keys in KEYBLOCK. This is
	* usually done by merge_selfsigs but at some places we only need the
	* main_kid not a full merge. The function also guarantees that all
	* pk->keyids are computed. */
	void
	setup_main_keyids (kbnode_t keyblock)
	{
	u32 kid[2], mainkid[2];
	kbnode_t kbctx, node;
	PKT_public_key *pk;

	if (keyblock->pkt->pkttype != PKT_PUBLIC_KEY)
	BUG ();
	pk = keyblock->pkt->pkt.public_key;

	keyid_from_pk (pk, mainkid);
	for (kbctx=NULL; (node = walk_kbnode (keyblock, &kbctx, 0)); )
	{
	if (!(node->pkt->pkttype == PKT_PUBLIC_KEY
	\|\| node->pkt->pkttype == PKT_PUBLIC_SUBKEY))
	continue;
	pk = node->pkt->pkt.public_key;
	keyid_from_pk (pk, kid); /* Make sure pk->keyid is set. */
	if (!pk->main_keyid[0] && !pk->main_keyid[1])
	{
	pk->main_keyid[0] = mainkid[0];
	pk->main_keyid[1] = mainkid[1];
	}
	}
	}


	/* KEYBLOCK corresponds to a public key block. This function merges
	* much of the information from the self-signed data into the public
	* key, public subkey and user id data structures. If you use the
	* high-level search API (e.g., get_pubkey) for looking up key blocks,
	* then you don't need to call this function. This function is
	* useful, however, if you change the keyblock, e.g., by adding or
	* removing a self-signed data packet. */
	void
	merge_keys_and_selfsig (ctrl_t ctrl, kbnode_t keyblock)
	{
	if (!keyblock)
	;
	else if (keyblock->pkt->pkttype == PKT_PUBLIC_KEY)
	merge_selfsigs (ctrl, keyblock);
	else
	log_debug ("FIXME: merging secret key blocks is not anymore available\n");
	}


	static int
	parse_key_usage (PKT_signature * sig)
	{
	int key_usage = 0;
	const byte *p;
	size_t n;
	byte flags;

	p = parse_sig_subpkt (sig, 1, SIGSUBPKT_KEY_FLAGS, &n);
	if (p && n)
	{
	/* First octet of the keyflags. */
	flags = *p;

	if (flags & 1)
	{
	key_usage \|= PUBKEY_USAGE_CERT;
	flags &= ~1;
	}

	if (flags & 2)
	{
	key_usage \|= PUBKEY_USAGE_SIG;
	flags &= ~2;
	}

	/* We do not distinguish between encrypting communications and
	encrypting storage. */
	if (flags & (0x04 \| 0x08))
	{
	key_usage \|= PUBKEY_USAGE_ENC;
	flags &= ~(0x04 \| 0x08);
	}

	if (flags & 0x20)
	{
	key_usage \|= PUBKEY_USAGE_AUTH;
	flags &= ~0x20;
	}

	if (flags)
	key_usage \|= PUBKEY_USAGE_UNKNOWN;

	if (!key_usage)
	key_usage \|= PUBKEY_USAGE_NONE;
	}
	else if (p) /* Key flags of length zero. */
	key_usage \|= PUBKEY_USAGE_NONE;

	/* We set PUBKEY_USAGE_UNKNOWN to indicate that this key has a
	capability that we do not handle. This serves to distinguish
	between a zero key usage which we handle as the default
	capabilities for that algorithm, and a usage that we do not
	handle. Likewise we use PUBKEY_USAGE_NONE to indicate that
	key_flags have been given but they do not specify any usage. */

	return key_usage;
	}


	/* Apply information from SIGNODE (which is the valid self-signature
	* associated with that UID) to the UIDNODE:
	* - weather the UID has been revoked
	* - assumed creation date of the UID
	* - temporary store the keyflags here
	* - temporary store the key expiration time here
	* - mark whether the primary user ID flag hat been set.
	* - store the preferences
	*/
	static void
	fixup_uidnode (KBNODE uidnode, KBNODE signode, u32 keycreated)
	{
	PKT_user_id *uid = uidnode->pkt->pkt.user_id;
	PKT_signature *sig = signode->pkt->pkt.signature;
	const byte p, sym, aead, hash, *zip;
	size_t n, nsym, naead, nhash, nzip;

	sig->flags.chosen_selfsig = 1;/* We chose this one. */
	uid->created = 0; /* Not created == invalid. */
	if (IS_UID_REV (sig))
	{
	uid->flags.revoked = 1;
	return; /* Has been revoked. */
	}
	else
	uid->flags.revoked = 0;

	uid->expiredate = sig->expiredate;

	if (sig->flags.expired)
	{
	uid->flags.expired = 1;
	return; /* Has expired. */
	}
	else
	uid->flags.expired = 0;

	uid->created = sig->timestamp; /* This one is okay. */
	uid->selfsigversion = sig->version;
	/* If we got this far, it's not expired :) */
	uid->flags.expired = 0;

	/* Store the key flags in the helper variable for later processing. */
	uid->help_key_usage = parse_key_usage (sig);

	/* Ditto for the key expiration. */
	p = parse_sig_subpkt (sig, 1, SIGSUBPKT_KEY_EXPIRE, NULL);
	if (p && buf32_to_u32 (p))
	uid->help_key_expire = keycreated + buf32_to_u32 (p);
	else
	uid->help_key_expire = 0;

	/* Set the primary user ID flag - we will later wipe out some
	* of them to only have one in our keyblock. */
	uid->flags.primary = 0;
	p = parse_sig_subpkt (sig, 1, SIGSUBPKT_PRIMARY_UID, NULL);
	if (p && *p)
	uid->flags.primary = 2;

	/* We could also query this from the unhashed area if it is not in
	* the hased area and then later try to decide which is the better
	* there should be no security problem with this.
	* For now we only look at the hashed one. */

	/* Now build the preferences list. These must come from the
	hashed section so nobody can modify the ciphers a key is
	willing to accept. */
	p = parse_sig_subpkt (sig, 1, SIGSUBPKT_PREF_SYM, &n);
	sym = p;
	nsym = p ? n : 0;
	p = parse_sig_subpkt (sig, 1, SIGSUBPKT_PREF_AEAD, &n);
	aead = p;
	naead = p ? n : 0;
	p = parse_sig_subpkt (sig, 1, SIGSUBPKT_PREF_HASH, &n);
	hash = p;
	nhash = p ? n : 0;
	p = parse_sig_subpkt (sig, 1, SIGSUBPKT_PREF_COMPR, &n);
	zip = p;
	nzip = p ? n : 0;
	if (uid->prefs)
	xfree (uid->prefs);
	n = nsym + naead + nhash + nzip;
	if (!n)
	uid->prefs = NULL;
	else
	{
	uid->prefs = xmalloc (sizeof (uid->prefs) (n + 1));
	n = 0;
	for (; nsym; nsym--, n++)
	{
	uid->prefs[n].type = PREFTYPE_SYM;
	uid->prefs[n].value = *sym++;
	}
	for (; naead; naead--, n++)
	{
	uid->prefs[n].type = PREFTYPE_AEAD;
	uid->prefs[n].value = *aead++;
	}
	for (; nhash; nhash--, n++)
	{
	uid->prefs[n].type = PREFTYPE_HASH;
	uid->prefs[n].value = *hash++;
	}
	for (; nzip; nzip--, n++)
	{
	uid->prefs[n].type = PREFTYPE_ZIP;
	uid->prefs[n].value = *zip++;
	}
	uid->prefs[n].type = PREFTYPE_NONE; /* End of list marker */
	uid->prefs[n].value = 0;
	}

	/* See whether we have the MDC feature. */
	uid->flags.mdc = 0;
	p = parse_sig_subpkt (sig, 1, SIGSUBPKT_FEATURES, &n);
	if (p && n && (p[0] & 0x01))
	uid->flags.mdc = 1;

	/* See whether we have the AEAD feature. */
	uid->flags.aead = 0;
	p = parse_sig_subpkt (sig, 1, SIGSUBPKT_FEATURES, &n);
	if (p && n && (p[0] & 0x02))
	uid->flags.aead = 1;

	/* And the keyserver modify flag. */
	uid->flags.ks_modify = 1;
	p = parse_sig_subpkt (sig, 1, SIGSUBPKT_KS_FLAGS, &n);
	if (p && n && (p[0] & 0x80))
	uid->flags.ks_modify = 0;
	}

	static void
	sig_to_revoke_info (PKT_signature * sig, struct revoke_info *rinfo)
	{
	rinfo->date = sig->timestamp;
	rinfo->algo = sig->pubkey_algo;
	rinfo->keyid[0] = sig->keyid[0];
	rinfo->keyid[1] = sig->keyid[1];
	}


	/* Given a keyblock, parse the key block and extract various pieces of
	* information and save them with the primary key packet and the user
	* id packets. For instance, some information is stored in signature
	* packets. We find the latest such valid packet (since the user can
	* change that information) and copy its contents into the
	* PKT_public_key.
	*
	* Note that R_REVOKED may be set to 0, 1 or 2.
	*
	* This function fills in the following fields in the primary key's
	* keyblock:
	*
	* main_keyid (computed)
	* revkey / numrevkeys (derived from self signed key data)
	* flags.valid (whether we have at least 1 self-sig)
	* flags.maybe_revoked (whether a designed revoked the key, but
	* we are missing the key to check the sig)
	* selfsigversion (highest version of any valid self-sig)
	* pubkey_usage (derived from most recent self-sig or most
	* recent user id)
	* has_expired (various sources)
	* expiredate (various sources)
	*
	* See the documentation for fixup_uidnode for how the user id packets
	* are modified. In addition to that the primary user id's is_primary
	* field is set to 1 and the other user id's is_primary are set to 0.
	*/
	static void
	merge_selfsigs_main (ctrl_t ctrl, kbnode_t keyblock, int *r_revoked,
	struct revoke_info *rinfo)
	{
	PKT_public_key *pk = NULL;
	KBNODE k;
	u32 kid[2];
	u32 sigdate, uiddate, uiddate2;
	KBNODE signode, uidnode, uidnode2;
	u32 curtime = make_timestamp ();
	unsigned int key_usage = 0;
	u32 keytimestamp = 0;
	u32 key_expire = 0;
	int key_expire_seen = 0;
	byte sigversion = 0;

	*r_revoked = 0;
	memset (rinfo, 0, sizeof (*rinfo));

	/* Section 11.1 of RFC 4880 determines the order of packets within a
	* message. There are three sections, which must occur in the
	* following order: the public key, the user ids and user attributes
	* and the subkeys. Within each section, each primary packet (e.g.,
	* a user id packet) is followed by one or more signature packets,
	* which modify that packet. */

	/* According to Section 11.1 of RFC 4880, the public key must be the
	first packet. Note that parse_keyblock_image ensures that the
	first packet is the public key. */
	if (keyblock->pkt->pkttype != PKT_PUBLIC_KEY)
	BUG ();
	pk = keyblock->pkt->pkt.public_key;
	keytimestamp = pk->timestamp;

	keyid_from_pk (pk, kid);
	pk->main_keyid[0] = kid[0];
	pk->main_keyid[1] = kid[1];

	if (pk->version < 4)
	{
	/* Before v4 the key packet itself contains the expiration date
	* and there was no way to change it, so we start with the one
	* from the key packet. */
	key_expire = pk->max_expiredate;
	key_expire_seen = 1;
	}

	/* First pass:
	*
	* - Find the latest direct key self-signature. We assume that the
	* newest one overrides all others.
	*
	* - Determine whether the key has been revoked.
	*
	* - Gather all revocation keys (unlike other data, we don't just
	* take them from the latest self-signed packet).
	*
	* - Determine max (sig[...]->version).
	*/

	/* Reset this in case this key was already merged. */
	xfree (pk->revkey);
	pk->revkey = NULL;
	pk->numrevkeys = 0;

	signode = NULL;
	sigdate = 0; /* Helper variable to find the latest signature. */

	/* According to Section 11.1 of RFC 4880, the public key comes first
	* and is immediately followed by any signature packets that modify
	* it. */
	for (k = keyblock;
	k && k->pkt->pkttype != PKT_USER_ID
	&& k->pkt->pkttype != PKT_ATTRIBUTE
	&& k->pkt->pkttype != PKT_PUBLIC_SUBKEY;
	k = k->next)
	{
	if (k->pkt->pkttype == PKT_SIGNATURE)
	{
	PKT_signature *sig = k->pkt->pkt.signature;
	if (sig->keyid[0] == kid[0] && sig->keyid[1] == kid[1])
	{ /* Self sig. */

	if (check_key_signature (ctrl, keyblock, k, NULL))
	; /* Signature did not verify. */
	else if (IS_KEY_REV (sig))
	{
	/* Key has been revoked - there is no way to
	* override such a revocation, so we theoretically
	* can stop now. We should not cope with expiration
	* times for revocations here because we have to
	* assume that an attacker can generate all kinds of
	* signatures. However due to the fact that the key
	* has been revoked it does not harm either and by
	* continuing we gather some more info on that
	* key. */
	*r_revoked = 1;
	sig_to_revoke_info (sig, rinfo);
	}
	else if (IS_KEY_SIG (sig))
	{
	/* Add the indicated revocations keys from all
	* signatures not just the latest. We do this
	* because you need multiple 1F sigs to properly
	* handle revocation keys (PGP does it this way, and
	* a revocation key could be sensitive and hence in
	* a different signature). */
	if (sig->revkey)
	{
	int i;

	pk->revkey =
	xrealloc (pk->revkey, sizeof (struct revocation_key) *
	(pk->numrevkeys + sig->numrevkeys));

	for (i = 0; i < sig->numrevkeys; i++, pk->numrevkeys++)
	{
	pk->revkey[pk->numrevkeys].class
	= sig->revkey[i].class;
	pk->revkey[pk->numrevkeys].algid
	= sig->revkey[i].algid;
	pk->revkey[pk->numrevkeys].fprlen
	= sig->revkey[i].fprlen;
	memcpy (pk->revkey[pk->numrevkeys].fpr,
	sig->revkey[i].fpr, sig->revkey[i].fprlen);
	memset (pk->revkey[pk->numrevkeys].fpr
	+ sig->revkey[i].fprlen,
	0,
	sizeof (sig->revkey[i].fpr)
	- sig->revkey[i].fprlen);
	}
	}

	if (sig->timestamp >= sigdate)
	{ /* This is the latest signature so far. */

	if (sig->flags.expired)
	; /* Signature has expired - ignore it. */
	else
	{
	sigdate = sig->timestamp;
	signode = k;
	if (sig->version > sigversion)
	sigversion = sig->version;

	}
	}
	}
	}
	}
	}

	/* Remove dupes from the revocation keys. */
	if (pk->revkey)
	{
	int i, j, x, changed = 0;

	for (i = 0; i < pk->numrevkeys; i++)
	{
	for (j = i + 1; j < pk->numrevkeys; j++)
	{
	if (memcmp (&pk->revkey[i], &pk->revkey[j],
	sizeof (struct revocation_key)) == 0)
	{
	/* remove j */

	for (x = j; x < pk->numrevkeys - 1; x++)
	pk->revkey[x] = pk->revkey[x + 1];

	pk->numrevkeys--;
	j--;
	changed = 1;
	}
	}
	}

	if (changed)
	pk->revkey = xrealloc (pk->revkey,
	pk->numrevkeys *
	sizeof (struct revocation_key));
	}

	/* SIGNODE is the 1F signature packet with the latest creation time.
	* Extract some information from it. */
	if (signode)
	{
	/* Some information from a direct key signature take precedence
	* over the same information given in UID sigs. */
	PKT_signature *sig = signode->pkt->pkt.signature;
	const byte *p;

	key_usage = parse_key_usage (sig);

	p = parse_sig_subpkt (sig, 1, SIGSUBPKT_KEY_EXPIRE, NULL);
	if (p && buf32_to_u32 (p))
	{
	key_expire = keytimestamp + buf32_to_u32 (p);
	key_expire_seen = 1;
	}

	/* Mark that key as valid: One direct key signature should
	* render a key as valid. */
	pk->flags.valid = 1;
	}

	/* Pass 1.5: Look for key revocation signatures that were not made
	* by the key (i.e. did a revocation key issue a revocation for
	* us?). Only bother to do this if there is a revocation key in the
	* first place and we're not revoked already. */

	if (!*r_revoked && pk->revkey)
	for (k = keyblock; k && k->pkt->pkttype != PKT_USER_ID; k = k->next)
	{
	if (k->pkt->pkttype == PKT_SIGNATURE)
	{
	PKT_signature *sig = k->pkt->pkt.signature;

	if (IS_KEY_REV (sig) &&
	(sig->keyid[0] != kid[0] \|\| sig->keyid[1] != kid[1]))
	{
	int rc = check_revocation_keys (ctrl, pk, sig);
	if (rc == 0)
	{
	*r_revoked = 2;
	sig_to_revoke_info (sig, rinfo);
	/* Don't continue checking since we can't be any
	* more revoked than this. */
	break;
	}
	else if (gpg_err_code (rc) == GPG_ERR_NO_PUBKEY)
	pk->flags.maybe_revoked = 1;

	/* A failure here means the sig did not verify, was
	* not issued by a revocation key, or a revocation
	* key loop was broken. If a revocation key isn't
	* findable, however, the key might be revoked and
	* we don't know it. */

	/* Fixme: In the future handle subkey and cert
	* revocations? PGP doesn't, but it's in 2440. */
	}
	}
	}

	/* Second pass: Look at the self-signature of all user IDs. */

	/* According to RFC 4880 section 11.1, user id and attribute packets
	* are in the second section, after the public key packet and before
	* the subkey packets. */
	signode = uidnode = NULL;
	sigdate = 0; /* Helper variable to find the latest signature in one UID. */
	for (k = keyblock; k && k->pkt->pkttype != PKT_PUBLIC_SUBKEY; k = k->next)
	{
	if (k->pkt->pkttype == PKT_USER_ID \|\| k->pkt->pkttype == PKT_ATTRIBUTE)
	{ /* New user id packet. */

	/* Apply the data from the most recent self-signed packet to
	* the preceding user id packet. */
	if (uidnode && signode)
	{
	fixup_uidnode (uidnode, signode, keytimestamp);
	pk->flags.valid = 1;
	}

	/* Clear SIGNODE. The only relevant self-signed data for
	* UIDNODE follows it. */
	if (k->pkt->pkttype == PKT_USER_ID)
	uidnode = k;
	else
	uidnode = NULL;

	signode = NULL;
	sigdate = 0;
	}
	else if (k->pkt->pkttype == PKT_SIGNATURE && uidnode)
	{
	PKT_signature *sig = k->pkt->pkt.signature;
	if (sig->keyid[0] == kid[0] && sig->keyid[1] == kid[1])
	{
	if (check_key_signature (ctrl, keyblock, k, NULL))
	; /* signature did not verify */
	else if ((IS_UID_SIG (sig) \|\| IS_UID_REV (sig))
	&& sig->timestamp >= sigdate)
	{
	/* Note: we allow invalidation of cert revocations
	* by a newer signature. An attacker can't use this
	* because a key should be revoked with a key revocation.
	* The reason why we have to allow for that is that at
	* one time an email address may become invalid but later
	* the same email address may become valid again (hired,
	* fired, hired again). */

	sigdate = sig->timestamp;
	signode = k;
	signode->pkt->pkt.signature->flags.chosen_selfsig = 0;
	if (sig->version > sigversion)
	sigversion = sig->version;
	}
	}
	}
	}
	if (uidnode && signode)
	{
	fixup_uidnode (uidnode, signode, keytimestamp);
	pk->flags.valid = 1;
	}

	/* If the key isn't valid yet, and we have
	* --allow-non-selfsigned-uid set, then force it valid. */
	if (!pk->flags.valid && opt.allow_non_selfsigned_uid)
	{
	if (opt.verbose)
	log_info (_("Invalid key %s made valid by"
	" --allow-non-selfsigned-uid\n"), keystr_from_pk (pk));
	pk->flags.valid = 1;
	}

	/* The key STILL isn't valid, so try and find an ultimately
	* trusted signature. */
	if (!pk->flags.valid)
	{
	uidnode = NULL;

	for (k = keyblock; k && k->pkt->pkttype != PKT_PUBLIC_SUBKEY;
	k = k->next)
	{
	if (k->pkt->pkttype == PKT_USER_ID)
	uidnode = k;
	else if (k->pkt->pkttype == PKT_SIGNATURE && uidnode)
	{
	PKT_signature *sig = k->pkt->pkt.signature;

	if (sig->keyid[0] != kid[0] \|\| sig->keyid[1] != kid[1])
	{
	PKT_public_key *ultimate_pk;

	ultimate_pk = xmalloc_clear (sizeof (*ultimate_pk));

	/* We don't want to use the full get_pubkey to avoid
	* infinite recursion in certain cases. There is no
	* reason to check that an ultimately trusted key is
	* still valid - if it has been revoked the user
	* should also remove the ultimate trust flag. */
	if (get_pubkey_fast (ultimate_pk, sig->keyid) == 0
	&& check_key_signature2 (ctrl,
	keyblock, k, ultimate_pk,
	NULL, NULL, NULL, NULL) == 0
	&& get_ownertrust (ctrl, ultimate_pk) == TRUST_ULTIMATE)
	{
	free_public_key (ultimate_pk);
	pk->flags.valid = 1;
	break;
	}

	free_public_key (ultimate_pk);
	}
	}
	}
	}

	/* Record the highest selfsig version so we know if this is a v3 key
	* through and through, or a v3 key with a v4 selfsig somewhere.
	* This is useful in a few places to know if the key must be treated
	* as PGP2-style or OpenPGP-style. Note that a selfsig revocation
	* with a higher version number will also raise this value. This is
	* okay since such a revocation must be issued by the user (i.e. it
	* cannot be issued by someone else to modify the key behavior.) */

	pk->selfsigversion = sigversion;

	/* Now that we had a look at all user IDs we can now get some
	* information from those user IDs. */

	if (!key_usage)
	{
	/* Find the latest user ID with key flags set. */
	uiddate = 0; /* Helper to find the latest user ID. */
	for (k = keyblock; k && k->pkt->pkttype != PKT_PUBLIC_SUBKEY;
	k = k->next)
	{
	if (k->pkt->pkttype == PKT_USER_ID)
	{
	PKT_user_id *uid = k->pkt->pkt.user_id;

	if (uid->help_key_usage && uid->created > uiddate)
	{
	key_usage = uid->help_key_usage;
	uiddate = uid->created;
	}
	}
	}
	}

	if (!key_usage)
	{
	/* No key flags at all: get it from the algo. */
	key_usage = openpgp_pk_algo_usage (pk->pubkey_algo);
	}
	else
	{
	/* Check that the usage matches the usage as given by the algo. */
	int x = openpgp_pk_algo_usage (pk->pubkey_algo);
	if (x) /* Mask it down to the actual allowed usage. */
	key_usage &= x;
	}

	/* Whatever happens, it's a primary key, so it can certify. */
	pk->pubkey_usage = key_usage \| PUBKEY_USAGE_CERT;

	if (!key_expire_seen)
	{
	/* Find the latest valid user ID with a key expiration set
	* Note, that this may be a different one from the above because
	* some user IDs may have no expiration date set. */
	uiddate = 0;
	for (k = keyblock; k && k->pkt->pkttype != PKT_PUBLIC_SUBKEY;
	k = k->next)
	{
	if (k->pkt->pkttype == PKT_USER_ID)
	{
	PKT_user_id *uid = k->pkt->pkt.user_id;
	if (uid->help_key_expire && uid->created > uiddate)
	{
	key_expire = uid->help_key_expire;
	uiddate = uid->created;
	}
	}
	}
	}

	/* Currently only v3 keys have a maximum expiration date, but I'll
	* bet v5 keys get this feature again. */
	if (key_expire == 0
	\|\| (pk->max_expiredate && key_expire > pk->max_expiredate))
	key_expire = pk->max_expiredate;

	pk->has_expired = key_expire >= curtime ? 0 : key_expire;
	pk->expiredate = key_expire;

	/* Fixme: we should see how to get rid of the expiretime fields but
	* this needs changes at other places too. */

	/* And now find the real primary user ID and delete all others. */
	uiddate = uiddate2 = 0;
	uidnode = uidnode2 = NULL;
	for (k = keyblock; k && k->pkt->pkttype != PKT_PUBLIC_SUBKEY; k = k->next)
	{
	if (k->pkt->pkttype == PKT_USER_ID && !k->pkt->pkt.user_id->attrib_data)
	{
	PKT_user_id *uid = k->pkt->pkt.user_id;
	if (uid->flags.primary)
	{
	if (uid->created > uiddate)
	{
	uiddate = uid->created;
	uidnode = k;
	}
	else if (uid->created == uiddate && uidnode)
	{
	/* The dates are equal, so we need to do a different
	* (and arbitrary) comparison. This should rarely,
	* if ever, happen. It's good to try and guarantee
	* that two different GnuPG users with two different
	* keyrings at least pick the same primary. */
	if (cmp_user_ids (uid, uidnode->pkt->pkt.user_id) > 0)
	uidnode = k;
	}
	}
	else
	{
	if (uid->created > uiddate2)
	{
	uiddate2 = uid->created;
	uidnode2 = k;
	}
	else if (uid->created == uiddate2 && uidnode2)
	{
	if (cmp_user_ids (uid, uidnode2->pkt->pkt.user_id) > 0)
	uidnode2 = k;
	}
	}
	}
	}
	if (uidnode)
	{
	for (k = keyblock; k && k->pkt->pkttype != PKT_PUBLIC_SUBKEY;
	k = k->next)
	{
	if (k->pkt->pkttype == PKT_USER_ID &&
	!k->pkt->pkt.user_id->attrib_data)
	{
	PKT_user_id *uid = k->pkt->pkt.user_id;
	if (k != uidnode)
	uid->flags.primary = 0;
	}
	}
	}
	else if (uidnode2)
	{
	/* None is flagged primary - use the latest user ID we have,
	* and disambiguate with the arbitrary packet comparison. */
	uidnode2->pkt->pkt.user_id->flags.primary = 1;
	}
	else
	{
	/* None of our uids were self-signed, so pick the one that
	* sorts first to be the primary. This is the best we can do
	* here since there are no self sigs to date the uids. */

	uidnode = NULL;

	for (k = keyblock; k && k->pkt->pkttype != PKT_PUBLIC_SUBKEY;
	k = k->next)
	{
	if (k->pkt->pkttype == PKT_USER_ID
	&& !k->pkt->pkt.user_id->attrib_data)
	{
	if (!uidnode)
	{
	uidnode = k;
	uidnode->pkt->pkt.user_id->flags.primary = 1;
	continue;
	}
	else
	{
	if (cmp_user_ids (k->pkt->pkt.user_id,
	uidnode->pkt->pkt.user_id) > 0)
	{
	uidnode->pkt->pkt.user_id->flags.primary = 0;
	uidnode = k;
	uidnode->pkt->pkt.user_id->flags.primary = 1;
	}
	else
	{
	/* just to be safe: */
	k->pkt->pkt.user_id->flags.primary = 0;
	}
	}
	}
	}
	}
	}


	/* Convert a buffer to a signature. Useful for 0x19 embedded sigs.
	* Caller must free the signature when they are done. */
	static PKT_signature *
	buf_to_sig (const byte * buf, size_t len)
	{
	PKT_signature *sig = xmalloc_clear (sizeof (PKT_signature));
	IOBUF iobuf = iobuf_temp_with_content (buf, len);
	int save_mode = set_packet_list_mode (0);

	if (parse_signature (iobuf, PKT_SIGNATURE, len, sig) != 0)
	{
	free_seckey_enc (sig);
	sig = NULL;
	}

	set_packet_list_mode (save_mode);
	iobuf_close (iobuf);

	return sig;
	}


	/* Use the self-signed data to fill in various fields in subkeys.
	*
	* KEYBLOCK is the whole keyblock. SUBNODE is the subkey to fill in.
	*
	* Sets the following fields on the subkey:
	*
	* main_keyid
	* flags.valid if the subkey has a valid self-sig binding
	* flags.revoked
	* flags.backsig
	* pubkey_usage
	* has_expired
	* expired_date
	*
	* On this subkey's most revent valid self-signed packet, the
	* following field is set:
	*
	* flags.chosen_selfsig
	*/
	static void
	merge_selfsigs_subkey (ctrl_t ctrl, kbnode_t keyblock, kbnode_t subnode)
	{
	PKT_public_key mainpk = NULL, subpk = NULL;
	PKT_signature *sig;
	KBNODE k;
	u32 mainkid[2];
	u32 sigdate = 0;
	KBNODE signode;
	u32 curtime = make_timestamp ();
	unsigned int key_usage = 0;
	u32 keytimestamp = 0;
	u32 key_expire = 0;
	const byte *p;

	if (subnode->pkt->pkttype != PKT_PUBLIC_SUBKEY)
	BUG ();
	mainpk = keyblock->pkt->pkt.public_key;
	if (mainpk->version < 4)
	return;/* (actually this should never happen) */
	keyid_from_pk (mainpk, mainkid);
	subpk = subnode->pkt->pkt.public_key;
	keytimestamp = subpk->timestamp;

	subpk->flags.valid = 0;
	subpk->flags.exact = 0;
	subpk->main_keyid[0] = mainpk->main_keyid[0];
	subpk->main_keyid[1] = mainpk->main_keyid[1];

	/* Find the latest key binding self-signature. */
	signode = NULL;
	sigdate = 0; /* Helper to find the latest signature. */
	for (k = subnode->next; k && k->pkt->pkttype != PKT_PUBLIC_SUBKEY;
	k = k->next)
	{
	if (k->pkt->pkttype == PKT_SIGNATURE)
	{
	sig = k->pkt->pkt.signature;
	if (sig->keyid[0] == mainkid[0] && sig->keyid[1] == mainkid[1])
	{
	if (check_key_signature (ctrl, keyblock, k, NULL))
	; /* Signature did not verify. */
	else if (IS_SUBKEY_REV (sig))
	{
	/* Note that this means that the date on a
	* revocation sig does not matter - even if the
	* binding sig is dated after the revocation sig,
	* the subkey is still marked as revoked. This
	* seems ok, as it is just as easy to make new
	* subkeys rather than re-sign old ones as the
	* problem is in the distribution. Plus, PGP (7)
	* does this the same way. */
	subpk->flags.revoked = 1;
	sig_to_revoke_info (sig, &subpk->revoked);
	/* Although we could stop now, we continue to
	* figure out other information like the old expiration
	* time. */
	}
	else if (IS_SUBKEY_SIG (sig) && sig->timestamp >= sigdate)
	{
	if (sig->flags.expired)
	; /* Signature has expired - ignore it. */
	else
	{
	sigdate = sig->timestamp;
	signode = k;
	signode->pkt->pkt.signature->flags.chosen_selfsig = 0;
	}
	}
	}
	}
	}

	/* No valid key binding. */
	if (!signode)
	return;

	sig = signode->pkt->pkt.signature;
	sig->flags.chosen_selfsig = 1; /* So we know which selfsig we chose later. */

	key_usage = parse_key_usage (sig);
	if (!key_usage)
	{
	/* No key flags at all: get it from the algo. */
	key_usage = openpgp_pk_algo_usage (subpk->pubkey_algo);
	}
	else
	{
	/* Check that the usage matches the usage as given by the algo. */
	int x = openpgp_pk_algo_usage (subpk->pubkey_algo);
	if (x) /* Mask it down to the actual allowed usage. */
	key_usage &= x;
	}

	subpk->pubkey_usage = key_usage;

	p = parse_sig_subpkt (sig, 1, SIGSUBPKT_KEY_EXPIRE, NULL);
	if (p && buf32_to_u32 (p))
	key_expire = keytimestamp + buf32_to_u32 (p);
	else
	key_expire = 0;

	subpk->has_expired = key_expire >= curtime ? 0 : key_expire;
	subpk->expiredate = key_expire;

	/* Algo doesn't exist. */
	if (openpgp_pk_test_algo (subpk->pubkey_algo))
	return;

	subpk->flags.valid = 1;

	/* Find the most recent 0x19 embedded signature on our self-sig. */
	if (!subpk->flags.backsig)
	{
	int seq = 0;
	size_t n;
	PKT_signature *backsig = NULL;

	sigdate = 0;

	/* We do this while() since there may be other embedded
	* signatures in the future. We only want 0x19 here. */

	while ((p = enum_sig_subpkt (sig, 1, SIGSUBPKT_SIGNATURE,
	&n, &seq, NULL)))
	if (n > 3
	&& ((p[0] == 3 && p[2] == 0x19) \|\| (p[0] == 4 && p[1] == 0x19)))
	{
	PKT_signature *tempsig = buf_to_sig (p, n);
	if (tempsig)
	{
	if (tempsig->timestamp > sigdate)
	{
	if (backsig)
	free_seckey_enc (backsig);

	backsig = tempsig;
	sigdate = backsig->timestamp;
	}
	else
	free_seckey_enc (tempsig);
	}
	}

	seq = 0;

	/* It is safe to have this in the unhashed area since the 0x19
	* is located on the selfsig for convenience, not security. */
	while ((p = enum_sig_subpkt (sig, 0, SIGSUBPKT_SIGNATURE,
	&n, &seq, NULL)))
	if (n > 3
	&& ((p[0] == 3 && p[2] == 0x19) \|\| (p[0] == 4 && p[1] == 0x19)))
	{
	PKT_signature *tempsig = buf_to_sig (p, n);
	if (tempsig)
	{
	if (tempsig->timestamp > sigdate)
	{
	if (backsig)
	free_seckey_enc (backsig);

	backsig = tempsig;
	sigdate = backsig->timestamp;
	}
	else
	free_seckey_enc (tempsig);
	}
	}

	if (backsig)
	{
	/* At this point, backsig contains the most recent 0x19 sig.
	* Let's see if it is good. */

	/* 2==valid, 1==invalid, 0==didn't check */
	if (check_backsig (mainpk, subpk, backsig) == 0)
	subpk->flags.backsig = 2;
	else
	subpk->flags.backsig = 1;

	free_seckey_enc (backsig);
	}
	}
	}


	/* Merge information from the self-signatures with the public key,
	* subkeys and user ids to make using them more easy.
	*
	* See documentation for merge_selfsigs_main, merge_selfsigs_subkey
	* and fixup_uidnode for exactly which fields are updated. */
	static void
	merge_selfsigs (ctrl_t ctrl, kbnode_t keyblock)
	{
	KBNODE k;
	int revoked;
	struct revoke_info rinfo;
	PKT_public_key *main_pk;
	prefitem_t *prefs;
	unsigned int mdc_feature;
	unsigned int aead_feature;

	if (keyblock->pkt->pkttype != PKT_PUBLIC_KEY)
	{
	if (keyblock->pkt->pkttype == PKT_SECRET_KEY)
	{
	log_error ("expected public key but found secret key "
	"- must stop\n");
	/* We better exit here because a public key is expected at
	* other places too. FIXME: Figure this out earlier and
	* don't get to here at all */
	g10_exit (1);
	}
	BUG ();
	}

	merge_selfsigs_main (ctrl, keyblock, &revoked, &rinfo);

	/* Now merge in the data from each of the subkeys. */
	for (k = keyblock; k; k = k->next)
	{
	if (k->pkt->pkttype == PKT_PUBLIC_SUBKEY)
	{
	merge_selfsigs_subkey (ctrl, keyblock, k);
	}
	}

	main_pk = keyblock->pkt->pkt.public_key;
	if (revoked \|\| main_pk->has_expired \|\| !main_pk->flags.valid)
	{
	/* If the primary key is revoked, expired, or invalid we
	* better set the appropriate flags on that key and all
	* subkeys. */
	for (k = keyblock; k; k = k->next)
	{
	if (k->pkt->pkttype == PKT_PUBLIC_KEY
	\|\| k->pkt->pkttype == PKT_PUBLIC_SUBKEY)
	{
	PKT_public_key *pk = k->pkt->pkt.public_key;
	if (!main_pk->flags.valid)
	pk->flags.valid = 0;
	if (revoked && !pk->flags.revoked)
	{
	pk->flags.revoked = revoked;
	memcpy (&pk->revoked, &rinfo, sizeof (rinfo));
	}
	if (main_pk->has_expired)
	{
	pk->has_expired = main_pk->has_expired;
	if (!pk->expiredate \|\| pk->expiredate > main_pk->expiredate)
	pk->expiredate = main_pk->expiredate;
	}
	}
	}
	return;
	}

	/* Set the preference list of all keys to those of the primary real
	* user ID. Note: we use these preferences when we don't know by
	* which user ID the key has been selected.
	* fixme: we should keep atoms of commonly used preferences or
	* use reference counting to optimize the preference lists storage.
	* FIXME: it might be better to use the intersection of
	* all preferences.
	* Do a similar thing for the MDC feature flag. */
	prefs = NULL;
	mdc_feature = aead_feature = 0;
	for (k = keyblock; k && k->pkt->pkttype != PKT_PUBLIC_SUBKEY; k = k->next)
	{
	if (k->pkt->pkttype == PKT_USER_ID
	&& !k->pkt->pkt.user_id->attrib_data
	&& k->pkt->pkt.user_id->flags.primary)
	{
	prefs = k->pkt->pkt.user_id->prefs;
	mdc_feature = k->pkt->pkt.user_id->flags.mdc;
	aead_feature = k->pkt->pkt.user_id->flags.aead;
	break;
	}
	}
	for (k = keyblock; k; k = k->next)
	{
	if (k->pkt->pkttype == PKT_PUBLIC_KEY
	\|\| k->pkt->pkttype == PKT_PUBLIC_SUBKEY)
	{
	PKT_public_key *pk = k->pkt->pkt.public_key;
	if (pk->prefs)
	xfree (pk->prefs);
	pk->prefs = copy_prefs (prefs);
	pk->flags.mdc = mdc_feature;
	pk->flags.aead = aead_feature;
	}
	}
	}



	/* See whether the key satisfies any additional requirements specified
	* in CTX. If so, return the node of an appropriate key or subkey.
	* Otherwise, return NULL if there was no appropriate key.
	*
	* Note that we do not return a reference, i.e. the result must not be
	* freed using 'release_kbnode'.
	*
	* In case the primary key is not required, select a suitable subkey.
	* We need the primary key if PUBKEY_USAGE_CERT is set in REQ_USAGE or
	* we are in PGP7 mode and PUBKEY_USAGE_SIG is set in
	* REQ_USAGE.
	*
	* If any of PUBKEY_USAGE_SIG, PUBKEY_USAGE_ENC and PUBKEY_USAGE_CERT
	* are set in REQ_USAGE, we filter by the key's function. Concretely,
	* if PUBKEY_USAGE_SIG and PUBKEY_USAGE_CERT are set, then we only
	* return a key if it is (at least) either a signing or a
	* certification key.
	*
	* If REQ_USAGE is set, then we reject any keys that are not good
	* (i.e., valid, not revoked, not expired, etc.). This allows the
	* getkey functions to be used for plain key listings.
	*
	* Sets the matched key's user id field (pk->user_id) to the user id
	* that matched the low-level search criteria or NULL.
	*
	* If R_FLAGS is not NULL set certain flags for more detailed error
	* reporting. Used flags are:
	*
	* - LOOKUP_ALL_SUBKEYS_EXPIRED :: All Subkeys are expired or have
	* been revoked.
	* - LOOKUP_NOT_SELECTED :: No suitable key found
	*
	* This function needs to handle several different cases:
	*
	* 1. No requested usage and no primary key requested
	* Examples for this case are that we have a keyID to be used
	* for decryption or verification.
	* 2. No usage but primary key requested
	* This is the case for all functions which work on an
	* entire keyblock, e.g. for editing or listing
	* 3. Usage and primary key requested
	* FIXME
	* 4. Usage but no primary key requested
	* FIXME
	*
	*/
	static kbnode_t
	finish_lookup (kbnode_t keyblock, unsigned int req_usage, int want_exact,
	int want_secret, unsigned int *r_flags)
	{
	kbnode_t k;

	/* If WANT_EXACT is set, the key or subkey that actually matched the
	low-level search criteria. */
	kbnode_t foundk = NULL;
	/* The user id (if any) that matched the low-level search criteria. */
	PKT_user_id *foundu = NULL;

	u32 latest_date;
	kbnode_t latest_key;
	PKT_public_key *pk;
	int req_prim;
	u32 curtime = make_timestamp ();

	if (r_flags)
	*r_flags = 0;

	#define USAGE_MASK (PUBKEY_USAGE_SIG\|PUBKEY_USAGE_ENC\|PUBKEY_USAGE_CERT)
	req_usage &= USAGE_MASK;

	/* Request the primary if we're certifying another key, and also if
	* signing data while --pgp7 is on since pgp 7 do
	* not understand signatures made by a signing subkey. PGP 8 does. */
	req_prim = ((req_usage & PUBKEY_USAGE_CERT)
	\|\| (PGP7 && (req_usage & PUBKEY_USAGE_SIG)));


	log_assert (keyblock->pkt->pkttype == PKT_PUBLIC_KEY);

	/* For an exact match mark the primary or subkey that matched the
	low-level search criteria. */
	if (want_exact)
	{
	for (k = keyblock; k; k = k->next)
	{
	if ((k->flag & 1))
	{
	log_assert (k->pkt->pkttype == PKT_PUBLIC_KEY
	\|\| k->pkt->pkttype == PKT_PUBLIC_SUBKEY);
	foundk = k;
	pk = k->pkt->pkt.public_key;
	pk->flags.exact = 1;
	break;
	}
	}
	}

	/* Get the user id that matched that low-level search criteria. */
	for (k = keyblock; k; k = k->next)
	{
	if ((k->flag & 2))
	{
	log_assert (k->pkt->pkttype == PKT_USER_ID);
	foundu = k->pkt->pkt.user_id;
	break;
	}
	}

	if (DBG_LOOKUP)
	log_debug ("finish_lookup: checking key %08lX (%s)(req_usage=%x)\n",
	(ulong) keyid_from_pk (keyblock->pkt->pkt.public_key, NULL),
	foundk ? "one" : "all", req_usage);

	if (!req_usage)
	{
	latest_key = foundk ? foundk : keyblock;
	goto found;
	}

	latest_date = 0;
	latest_key = NULL;
	/* Set LATEST_KEY to the latest (the one with the most recent
	* timestamp) good (valid, not revoked, not expired, etc.) subkey.
	*
	* Don't bother if we are only looking for a primary key or we need
	* an exact match and the exact match is not a subkey. */
	if (req_prim \|\| (foundk && foundk->pkt->pkttype != PKT_PUBLIC_SUBKEY))
	;
	else
	{
	kbnode_t nextk;
	int n_subkeys = 0;
	int n_revoked_or_expired = 0;

	/* Either start a loop or check just this one subkey. */
	for (k = foundk ? foundk : keyblock; k; k = nextk)
	{
	if (foundk)
	{
	/* If FOUNDK is not NULL, then only consider that exact
	key, i.e., don't iterate. */
	nextk = NULL;
	}
	else
	nextk = k->next;

	if (k->pkt->pkttype != PKT_PUBLIC_SUBKEY)
	continue;

	pk = k->pkt->pkt.public_key;
	if (DBG_LOOKUP)
	log_debug ("\tchecking subkey %08lX\n",
	(ulong) keyid_from_pk (pk, NULL));

	if (!pk->flags.valid)
	{
	if (DBG_LOOKUP)
	log_debug ("\tsubkey not valid\n");
	continue;
	}
	if (!((pk->pubkey_usage & USAGE_MASK) & req_usage))
	{
	if (DBG_LOOKUP)
	log_debug ("\tusage does not match: want=%x have=%x\n",
	req_usage, pk->pubkey_usage);
	continue;
	}

	n_subkeys++;
	if (pk->flags.revoked)
	{
	if (DBG_LOOKUP)
	log_debug ("\tsubkey has been revoked\n");
	n_revoked_or_expired++;
	continue;
	}
	if (pk->has_expired)
	{
	if (DBG_LOOKUP)
	log_debug ("\tsubkey has expired\n");
	n_revoked_or_expired++;
	continue;
	}
	if (pk->timestamp > curtime && !opt.ignore_valid_from)
	{
	if (DBG_LOOKUP)
	log_debug ("\tsubkey not yet valid\n");
	continue;
	}

	if (want_secret && agent_probe_secret_key (NULL, pk))
	{
	if (DBG_LOOKUP)
	log_debug ("\tno secret key\n");
	continue;
	}

	if (DBG_LOOKUP)
	log_debug ("\tsubkey might be fine\n");
	/* In case a key has a timestamp of 0 set, we make sure
	that it is used. A better change would be to compare
	">=" but that might also change the selected keys and
	is as such a more intrusive change. */
	if (pk->timestamp > latest_date \|\| (!pk->timestamp && !latest_date))
	{
	latest_date = pk->timestamp;
	latest_key = k;
	}
	}
	if (n_subkeys == n_revoked_or_expired && r_flags)
	*r_flags \|= LOOKUP_ALL_SUBKEYS_EXPIRED;
	}

	/* Check if the primary key is ok (valid, not revoke, not expire,
	* matches requested usage) if:
	*
	* - we didn't find an appropriate subkey and we're not doing an
	* exact search,
	*
	* - we're doing an exact match and the exact match was the
	* primary key, or,
	*
	* - we're just considering the primary key. */
	if ((!latest_key && !want_exact) \|\| foundk == keyblock \|\| req_prim)
	{
	if (DBG_LOOKUP && !foundk && !req_prim)
	log_debug ("\tno suitable subkeys found - trying primary\n");
	pk = keyblock->pkt->pkt.public_key;
	if (!pk->flags.valid)
	{
	if (DBG_LOOKUP)
	log_debug ("\tprimary key not valid\n");
	}
	else if (!((pk->pubkey_usage & USAGE_MASK) & req_usage))
	{
	if (DBG_LOOKUP)
	log_debug ("\tprimary key usage does not match: "
	"want=%x have=%x\n", req_usage, pk->pubkey_usage);
	}
	else if (pk->flags.revoked)
	{
	if (DBG_LOOKUP)
	log_debug ("\tprimary key has been revoked\n");
	}
	else if (pk->has_expired)
	{
	if (DBG_LOOKUP)
	log_debug ("\tprimary key has expired\n");
	}
	else /* Okay. */
	{
	if (DBG_LOOKUP)
	log_debug ("\tprimary key may be used\n");
	latest_key = keyblock;
	}
	}

	if (!latest_key)
	{
	if (DBG_LOOKUP)
	log_debug ("\tno suitable key found - giving up\n");
	if (r_flags)
	*r_flags \|= LOOKUP_NOT_SELECTED;
	return NULL; /* Not found. */
	}

	found:
	if (DBG_LOOKUP)
	log_debug ("\tusing key %08lX\n",
	(ulong) keyid_from_pk (latest_key->pkt->pkt.public_key, NULL));

	if (latest_key)
	{
	pk = latest_key->pkt->pkt.public_key;
	free_user_id (pk->user_id);
	pk->user_id = scopy_user_id (foundu);
	}

	if (latest_key != keyblock && opt.verbose)
	{
	char *tempkeystr =
	xstrdup (keystr_from_pk (latest_key->pkt->pkt.public_key));
	log_info (_("using subkey %s instead of primary key %s\n"),
	tempkeystr, keystr_from_pk (keyblock->pkt->pkt.public_key));
	xfree (tempkeystr);
	}

	cache_put_keyblock (keyblock);

	return latest_key ? latest_key : keyblock; /* Found. */
	}


	/* Print a KEY_CONSIDERED status line. */
	static void
	print_status_key_considered (kbnode_t keyblock, unsigned int flags)
	{
	char hexfpr[2*MAX_FINGERPRINT_LEN + 1];
	kbnode_t node;
	char flagbuf[20];

	if (!is_status_enabled ())
	return;

	for (node=keyblock; node; node = node->next)
	if (node->pkt->pkttype == PKT_PUBLIC_KEY
	\|\| node->pkt->pkttype == PKT_SECRET_KEY)
	break;
	if (!node)
	{
	log_error ("%s: keyblock w/o primary key\n", __func__);
	return;
	}

	hexfingerprint (node->pkt->pkt.public_key, hexfpr, sizeof hexfpr);
	snprintf (flagbuf, sizeof flagbuf, " %u", flags);
	write_status_strings (STATUS_KEY_CONSIDERED, hexfpr, flagbuf, NULL);
	}



	/* A high-level function to lookup keys.
	*
	* This function builds on top of the low-level keydb API. It first
	* searches the database using the description stored in CTX->ITEMS,
	* then it filters the results using CTX and, finally, if WANT_SECRET
	* is set, it ignores any keys for which no secret key is available.
	*
	* Unlike the low-level search functions, this function also merges
	* all of the self-signed data into the keys, subkeys and user id
	* packets (see the merge_selfsigs for details).
	*
	* On success the key's keyblock is stored at *RET_KEYBLOCK, and the
	* specific subkey is stored at *RET_FOUND_KEY. Note that we do not
	* return a reference in *RET_FOUND_KEY, i.e. the result must not be
	* freed using 'release_kbnode', and it is only valid until
	* *RET_KEYBLOCK is deallocated. Therefore, if RET_FOUND_KEY is not
	* NULL, then RET_KEYBLOCK must not be NULL. */
	static int
	lookup (ctrl_t ctrl, getkey_ctx_t ctx, int want_secret,
	kbnode_t ret_keyblock, kbnode_t ret_found_key)
	{
	int rc;
	int no_suitable_key = 0;
	KBNODE keyblock = NULL;
	KBNODE found_key = NULL;
	unsigned int infoflags;

	log_assert (ret_found_key == NULL \|\| ret_keyblock != NULL);
	if (ret_keyblock)
	*ret_keyblock = NULL;

	for (;;)
	{
	rc = keydb_search (ctx->kr_handle, ctx->items, ctx->nitems, NULL);
	if (rc)
	break;

	/* If we are iterating over the entire database, then we need to
	* change from KEYDB_SEARCH_MODE_FIRST, which does an implicit
	* reset, to KEYDB_SEARCH_MODE_NEXT, which gets the next record. */
	if (ctx->nitems && ctx->items->mode == KEYDB_SEARCH_MODE_FIRST)
	ctx->items->mode = KEYDB_SEARCH_MODE_NEXT;

	rc = keydb_get_keyblock (ctx->kr_handle, &keyblock);
	if (rc)
	{
	log_error ("keydb_get_keyblock failed: %s\n", gpg_strerror (rc));
	goto skip;
	}

	if (want_secret)
	{
	rc = agent_probe_any_secret_key (NULL, keyblock);
	if (gpg_err_code(rc) == GPG_ERR_NO_SECKEY)
	goto skip; /* No secret key available. */
	if (rc)
	goto found; /* Unexpected error. */
	}

	/* Warning: node flag bits 0 and 1 should be preserved by
	* merge_selfsigs. */
	merge_selfsigs (ctrl, keyblock);
	found_key = finish_lookup (keyblock, ctx->req_usage, ctx->exact,
	want_secret, &infoflags);
	print_status_key_considered (keyblock, infoflags);
	if (found_key)
	{
	no_suitable_key = 0;
	goto found;
	}
	else
	{
	no_suitable_key = 1;
	}

	skip:
	/* Release resources and continue search. */
	release_kbnode (keyblock);
	keyblock = NULL;
	/* The keyblock cache ignores the current "file position".
	* Thus, if we request the next result and the cache matches
	* (and it will since it is what we just looked for), we'll get
	* the same entry back! We can avoid this infinite loop by
	* disabling the cache. */
	keydb_disable_caching (ctx->kr_handle);
	}

	found:
	if (rc && gpg_err_code (rc) != GPG_ERR_NOT_FOUND)
	log_error ("keydb_search failed: %s\n", gpg_strerror (rc));

	if (!rc)
	{
	if (ret_keyblock)
	{
	ret_keyblock = keyblock; / Return the keyblock. */
	keyblock = NULL;
	}
	}
	else if (gpg_err_code (rc) == GPG_ERR_NOT_FOUND && no_suitable_key)
	rc = want_secret? GPG_ERR_UNUSABLE_SECKEY : GPG_ERR_UNUSABLE_PUBKEY;
	else if (gpg_err_code (rc) == GPG_ERR_NOT_FOUND)
	rc = want_secret? GPG_ERR_NO_SECKEY : GPG_ERR_NO_PUBKEY;

	release_kbnode (keyblock);

	if (ret_found_key)
	{
	if (! rc)
	*ret_found_key = found_key;
	else
	*ret_found_key = NULL;
	}

	return rc;
	}


	gpg_error_t
	get_seckey_default_or_card (ctrl_t ctrl, PKT_public_key *pk,
	const byte *fpr_card, size_t fpr_len)
	{
	gpg_error_t err;
	strlist_t namelist = NULL;

	const char *def_secret_key = parse_def_secret_key (ctrl);

	if (def_secret_key)
	add_to_strlist (&namelist, def_secret_key);
	else if (fpr_card)
	return get_pubkey_byfprint (ctrl, pk, NULL, fpr_card, fpr_len);

	if (!fpr_card
	\|\| (def_secret_key && def_secret_key[strlen (def_secret_key)-1] == '!'))
	err = key_byname (ctrl, NULL, namelist, pk, 1, 0, NULL, NULL);
	else
	{ /* Default key is specified and card key is also available. */
	kbnode_t k, keyblock = NULL;

	err = key_byname (ctrl, NULL, namelist, pk, 1, 0, &keyblock, NULL);
	if (!err)
	for (k = keyblock; k; k = k->next)
	{
	PKT_public_key *pk_candidate;
	char fpr[MAX_FINGERPRINT_LEN];

	if (k->pkt->pkttype != PKT_PUBLIC_KEY
	&&k->pkt->pkttype != PKT_PUBLIC_SUBKEY)
	continue;

	pk_candidate = k->pkt->pkt.public_key;
	if (!pk_candidate->flags.valid)
	continue;
	if (!((pk_candidate->pubkey_usage & USAGE_MASK) & pk->req_usage))
	continue;
	fingerprint_from_pk (pk_candidate, fpr, NULL);
	if (!memcmp (fpr_card, fpr, fpr_len))
	{
	release_public_key_parts (pk);
	copy_public_key (pk, pk_candidate);
	break;
	}
	}
	release_kbnode (keyblock);
	}

	free_strlist (namelist);

	return err;
	}

	/*********************************************
	********* User ID printing helpers *****
	*********************************************/

	/* Return a string with a printable representation of the user_id.
	* this string must be freed by xfree. If R_NOUID is not NULL it is
	* set to true if a user id was not found; otherwise to false. */
	static char *
	get_user_id_string (ctrl_t ctrl, u32 * keyid, int mode)
	{
	char *name;
	unsigned int namelen;
	char *p;

	log_assert (mode != 2);

	name = cache_get_uid_bykid (keyid, &namelen);
	if (!name)
	{
	/* Get it so that the cache will be filled. */
	if (!get_pubkey (ctrl, NULL, keyid))
	name = cache_get_uid_bykid (keyid, &namelen);
	}

	if (name)
	{
	if (mode)
	p = xasprintf ("%08lX%08lX %.*s",
	(ulong) keyid[0], (ulong) keyid[1], namelen, name);
	else
	p = xasprintf ("%s %.*s", keystr (keyid), namelen, name);

	xfree (name);
	}
	else
	{
	if (mode)
	p = xasprintf ("%08lX%08lX [?]", (ulong) keyid[0], (ulong) keyid[1]);
	else
	p = xasprintf ("%s [?]", keystr (keyid));
	}

	return p;
	}


	char *
	get_user_id_string_native (ctrl_t ctrl, u32 * keyid)
	{
	char *p = get_user_id_string (ctrl, keyid, 0);
	char *p2 = utf8_to_native (p, strlen (p), 0);
	xfree (p);
	return p2;
	}


	char *
	get_long_user_id_string (ctrl_t ctrl, u32 * keyid)
	{
	return get_user_id_string (ctrl, keyid, 1);
	}


	/* Please try to use get_user_byfpr instead of this one. */
	char *
	get_user_id (ctrl_t ctrl, u32 keyid, size_t rn, int *r_nouid)
	{
	char *name;
	unsigned int namelen;

	if (r_nouid)
	*r_nouid = 0;

	name = cache_get_uid_bykid (keyid, &namelen);
	if (!name)
	{
	/* Get it so that the cache will be filled. */
	if (!get_pubkey (ctrl, NULL, keyid))
	name = cache_get_uid_bykid (keyid, &namelen);
	}

	if (!name)
	{
	name = xstrdup (user_id_not_found_utf8 ());
	namelen = strlen (name);
	if (r_nouid)
	*r_nouid = 1;
	}

	if (rn && name)
	*rn = namelen;
	return name;
	}


	/* Please try to use get_user_id_byfpr_native instead of this one. */
	char *
	get_user_id_native (ctrl_t ctrl, u32 *keyid)
	{
	size_t rn;
	char *p = get_user_id (ctrl, keyid, &rn, NULL);
	char *p2 = utf8_to_native (p, rn, 0);
	xfree (p);
	return p2;
	}


	/* Return the user id for a key designated by its fingerprint, FPR,
	which must be MAX_FINGERPRINT_LEN bytes in size. Note: the
	returned string, which must be freed using xfree, may not be NUL
	terminated. To determine the length of the string, you must use
	RN. /
	static char *
	get_user_id_byfpr (ctrl_t ctrl, const byte fpr, size_t fprlen, size_t rn)
	{
	char *name;

	name = cache_get_uid_byfpr (fpr, fprlen, rn);
	if (!name)
	{
	/* Get it so that the cache will be filled. */
	if (!get_pubkey_byfprint (ctrl, NULL, NULL, fpr, fprlen))
	name = cache_get_uid_byfpr (fpr, fprlen, rn);
	}

	if (!name)
	{
	name = xstrdup (user_id_not_found_utf8 ());
	*rn = strlen (name);
	}

	return name;
	}

	/* Like get_user_id_byfpr, but convert the string to the native
	encoding. The returned string needs to be freed. Unlike
	get_user_id_byfpr, the returned string is NUL terminated. */
	char *
	get_user_id_byfpr_native (ctrl_t ctrl, const byte *fpr, size_t fprlen)
	{
	size_t rn;
	char *p = get_user_id_byfpr (ctrl, fpr, fprlen, &rn);
	char *p2 = utf8_to_native (p, rn, 0);
	xfree (p);
	return p2;
	}


	/* Return the database handle used by this context. The context still
	owns the handle. */
	KEYDB_HANDLE
	get_ctx_handle (GETKEY_CTX ctx)
	{
	return ctx->kr_handle;
	}

	static void
	free_akl (struct akl *akl)
	{
	if (! akl)
	return;

	if (akl->spec)
	free_keyserver_spec (akl->spec);

	xfree (akl);
	}

	void
	release_akl (void)
	{
	while (opt.auto_key_locate)
	{
	struct akl *akl2 = opt.auto_key_locate;
	opt.auto_key_locate = opt.auto_key_locate->next;
	free_akl (akl2);
	}
	}


	/* Returns true if the AKL is empty or has only the local method
	* active. */
	int
	akl_empty_or_only_local (void)
	{
	struct akl *akl;
	int any = 0;

	for (akl = opt.auto_key_locate; akl; akl = akl->next)
	if (akl->type != AKL_NODEFAULT && akl->type != AKL_LOCAL)
	{
	any = 1;
	break;
	}

	return !any;
	}


	/* Returns false on error. */
	int
	parse_auto_key_locate (const char *options_arg)
	{
	char *tok;
	char options, options_buf;

	options = options_buf = xstrdup (options_arg);
	while ((tok = optsep (&options)))
	{
	struct akl akl, check, *last = NULL;
	int dupe = 0;

	if (tok[0] == '\0')
	continue;

	akl = xmalloc_clear (sizeof (*akl));

	if (ascii_strcasecmp (tok, "clear") == 0)
	{
	xfree (akl);
	free_akl (opt.auto_key_locate);
	opt.auto_key_locate = NULL;
	continue;
	}
	else if (ascii_strcasecmp (tok, "nodefault") == 0)
	akl->type = AKL_NODEFAULT;
	else if (ascii_strcasecmp (tok, "local") == 0)
	akl->type = AKL_LOCAL;
	else if (ascii_strcasecmp (tok, "ldap") == 0)
	akl->type = AKL_LDAP;
	else if (ascii_strcasecmp (tok, "keyserver") == 0)
	akl->type = AKL_KEYSERVER;
	else if (ascii_strcasecmp (tok, "cert") == 0)
	akl->type = AKL_CERT;
	else if (ascii_strcasecmp (tok, "pka") == 0)
	akl->type = AKL_PKA;
	else if (ascii_strcasecmp (tok, "dane") == 0)
	akl->type = AKL_DANE;
	else if (ascii_strcasecmp (tok, "wkd") == 0)
	akl->type = AKL_WKD;
	else if ((akl->spec = parse_keyserver_uri (tok, 1)))
	akl->type = AKL_SPEC;
	else
	{
	free_akl (akl);
	xfree (options_buf);
	return 0;
	}

	/* We must maintain the order the user gave us */
	for (check = opt.auto_key_locate; check;
	last = check, check = check->next)
	{
	/* Check for duplicates */
	if (check->type == akl->type
	&& (akl->type != AKL_SPEC
	\|\| (akl->type == AKL_SPEC
	&& strcmp (check->spec->uri, akl->spec->uri) == 0)))
	{
	dupe = 1;
	free_akl (akl);
	break;
	}
	}

	if (!dupe)
	{
	if (last)
	last->next = akl;
	else
	opt.auto_key_locate = akl;
	}
	}

	xfree (options_buf);
	return 1;
	}



	/* The list of key origins. */
	static struct {
	const char *name;
	int origin;
	} key_origin_list[] =
	{
	{ "self", KEYORG_SELF },
	{ "file", KEYORG_FILE },
	{ "url", KEYORG_URL },
	{ "wkd", KEYORG_WKD },
	{ "dane", KEYORG_DANE },
	{ "ks-pref", KEYORG_KS_PREF },
	{ "ks", KEYORG_KS },
	{ "unknown", KEYORG_UNKNOWN }
	};

	/* Parse the argument for --key-origin. Return false on error. */
	int
	parse_key_origin (char *string)
	{
	int i;
	char *comma;

	comma = strchr (string, ',');
	if (comma)
	*comma = 0;

	if (!ascii_strcasecmp (string, "help"))
	{
	log_info (_("valid values for option '%s':\n"), "--key-origin");
	for (i=0; i < DIM (key_origin_list); i++)
	log_info (" %s\n", key_origin_list[i].name);
	g10_exit (1);
	}

	for (i=0; i < DIM (key_origin_list); i++)
	if (!ascii_strcasecmp (string, key_origin_list[i].name))
	{
	opt.key_origin = key_origin_list[i].origin;
	xfree (opt.key_origin_url);
	opt.key_origin_url = NULL;
	if (comma && comma[1])
	{
	opt.key_origin_url = xstrdup (comma+1);
	trim_spaces (opt.key_origin_url);
	}

	return 1;
	}

	if (comma)
	*comma = ',';
	return 0;
	}

	/* Return a string or "?" for the key ORIGIN. */
	const char *
	key_origin_string (int origin)
	{
	int i;

	for (i=0; i < DIM (key_origin_list); i++)
	if (key_origin_list[i].origin == origin)
	return key_origin_list[i].name;
	return "?";
	}



	/* Returns true if a secret key is available for the public key with
	key id KEYID; returns false if not. This function ignores legacy
	keys. Note: this is just a fast check and does not tell us whether
	the secret key is valid; this check merely indicates whether there
	is some secret key with the specified key id. */
	int
	have_secret_key_with_kid (u32 *keyid)
	{
	gpg_error_t err;
	KEYDB_HANDLE kdbhd;
	KEYDB_SEARCH_DESC desc;
	kbnode_t keyblock;
	kbnode_t node;
	int result = 0;

	kdbhd = keydb_new ();
	if (!kdbhd)
	return 0;
	memset (&desc, 0, sizeof desc);
	desc.mode = KEYDB_SEARCH_MODE_LONG_KID;
	desc.u.kid[0] = keyid[0];
	desc.u.kid[1] = keyid[1];
	while (!result)
	{
	err = keydb_search (kdbhd, &desc, 1, NULL);
	if (err)
	break;

	err = keydb_get_keyblock (kdbhd, &keyblock);
	if (err)
	{
	log_error (_("error reading keyblock: %s\n"), gpg_strerror (err));
	break;
	}

	for (node = keyblock; node; node = node->next)
	{
	/* Bit 0 of the flags is set if the search found the key
	using that key or subkey. Note: a search will only ever
	match a single key or subkey. */
	if ((node->flag & 1))
	{
	log_assert (node->pkt->pkttype == PKT_PUBLIC_KEY
	\|\| node->pkt->pkttype == PKT_PUBLIC_SUBKEY);

	if (!agent_probe_secret_key (NULL, node->pkt->pkt.public_key))
	result = 1; /* Secret key available. */
	else
	result = 0;

	break;
	}
	}
	release_kbnode (keyblock);
	}

	keydb_release (kdbhd);
	return result;
	}
	diff --git a/g10/keydb.h b/g10/keydb.h
	index 72ba98d04..6fbc432fd 100644
	--- a/g10/keydb.h
	+++ b/g10/keydb.h
	@@ -1,563 +1,565 @@
	/* keydb.h - Key database
	* Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
	* 2006, 2010 Free Software Foundation, Inc.
	* Copyright (C) 2015, 2016 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 G10_KEYDB_H
	#define G10_KEYDB_H

	#include "../common/types.h"
	#include "../common/util.h"
	#include "packet.h"

	/* What qualifies as a certification (key-signature in contrast to a
	* data signature)? Note that a back signature is special and can be
	* made by key and data signatures capable subkeys.) */
	#define IS_CERT(s) (IS_KEY_SIG(s) \
	\|\| IS_UID_SIG(s) \
	\|\| IS_SUBKEY_SIG(s) \
	\|\| IS_KEY_REV(s) \
	\|\| IS_UID_REV(s) \
	\|\| IS_SUBKEY_REV(s) \
	\|\| IS_ATTST_SIGS(s) )
	#define IS_SIG(s) (!IS_CERT(s))
	#define IS_KEY_SIG(s) ((s)->sig_class == 0x1f)
	#define IS_UID_SIG(s) (((s)->sig_class & ~3) == 0x10)
	#define IS_ATTST_SIGS(s) ((s)->sig_class == 0x16)
	#define IS_SUBKEY_SIG(s) ((s)->sig_class == 0x18)
	#define IS_BACK_SIG(s) ((s)->sig_class == 0x19)
	#define IS_KEY_REV(s) ((s)->sig_class == 0x20)
	#define IS_UID_REV(s) ((s)->sig_class == 0x30)
	#define IS_SUBKEY_REV(s) ((s)->sig_class == 0x28)

	struct getkey_ctx_s;
	typedef struct getkey_ctx_s *GETKEY_CTX;
	typedef struct getkey_ctx_s *getkey_ctx_t;

	/****************
	* A Keyblock is all packets which form an entire certificate;
	* i.e. the public key, certificate, trust packets, user ids,
	* signatures, and subkey.
	*
	* This structure is also used to bind arbitrary packets together.
	*/

	struct kbnode_struct
	{
	kbnode_t next;
	PACKET *pkt;
	int flag; /* Local use during keyblock processing (not cloned).*/
	unsigned int tag; /* Ditto. */
	int private_flag;
	};

	#define is_deleted_kbnode(a) ((a)->private_flag & 1)
	#define is_cloned_kbnode(a) ((a)->private_flag & 2)


	/*
	* A structure to store key identification as well as some stuff
	* needed for key validation.
	*/
	struct key_item {
	struct key_item *next;
	unsigned int ownertrust,min_ownertrust;
	byte trust_depth;
	byte trust_value;
	char *trust_regexp;
	u32 kid[2];
	};


	/* Bit flags used with build_pk_list. */
	enum
	{
	PK_LIST_ENCRYPT_TO = 1, /* This is an encrypt-to recipient. */
	PK_LIST_HIDDEN = 2, /* This is a hidden recipient. */
	PK_LIST_CONFIG = 4, /* Specified via config file. */
	PK_LIST_FROM_FILE = 8 /* Take key from file with that name. */
	};

	/* To store private data in the flags the private data must be left
	* shifted by this value. */
	enum
	{
	PK_LIST_SHIFT = 4
	};


	/* Structure to hold a couple of public key certificates. */
	typedef struct pk_list PK_LIST; / Deprecated. */
	typedef struct pk_list *pk_list_t;
	struct pk_list
	{
	PK_LIST next;
	PKT_public_key *pk;
	int flags; /* See PK_LIST_ constants. */
	};

	/* Structure to hold a list of secret key certificates. */
	typedef struct sk_list *SK_LIST;
	struct sk_list
	{
	SK_LIST next;
	PKT_public_key *pk;
	int mark; /* not used */
	};

	/* structure to collect all information which can be used to
	* identify a public key */
	typedef struct pubkey_find_info *PUBKEY_FIND_INFO;
	struct pubkey_find_info {
	u32 keyid[2];
	unsigned nbits;
	byte pubkey_algo;
	byte fingerprint[MAX_FINGERPRINT_LEN];
	char userid[1];
	};


	/* Helper type for preference functions. */
	union pref_hint
	{
	int digest_length;
	};


	/* Constants to describe from where a key was fetched or updated. */
	enum
	{
	KEYORG_UNKNOWN = 0,
	KEYORG_KS = 1, /* Public keyserver. */
	KEYORG_KS_PREF = 2, /* Preferred keysrver. */
	KEYORG_DANE = 3, /* OpenPGP DANE. */
	KEYORG_WKD = 4, /* Web Key Directory. */
	KEYORG_URL = 5, /* Trusted URL. */
	KEYORG_FILE = 6, /* Trusted file. */
	KEYORG_SELF = 7 /* We generated it. */
	};


	/*
	* Check whether the signature SIG is in the klist K.
	*/
	static inline struct key_item *
	is_in_klist (struct key_item k, PKT_signature sig)
	{
	for (; k; k = k->next)
	{
	if (k->kid[0] == sig->keyid[0] && k->kid[1] == sig->keyid[1])
	return k;
	}
	return NULL;
	}



	/-- keydb.c --/

	#define KEYDB_RESOURCE_FLAG_PRIMARY 2 /* The primary resource. */
	#define KEYDB_RESOURCE_FLAG_DEFAULT 4 /* The default one. */
	#define KEYDB_RESOURCE_FLAG_READONLY 8 /* Open in read only mode. */
	#define KEYDB_RESOURCE_FLAG_GPGVDEF 16 /* Default file for gpgv. */

	/* Format a search term for debugging output. The caller must free
	the result. */
	char keydb_search_desc_dump (struct keydb_search_desc desc);

	/* Register a resource (keyring or keybox). */
	gpg_error_t keydb_add_resource (const char *url, unsigned int flags);

	/* Dump some statistics to the log. */
	void keydb_dump_stats (void);

	/* Create a new database handle. Returns NULL on error, sets ERRNO,
	and prints an error diagnostic. */
	KEYDB_HANDLE keydb_new (void);

	/* Free all resources owned by the database handle. */
	void keydb_release (KEYDB_HANDLE 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 keydb_lock (KEYDB_HANDLE hd);

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

	/* Save the last found state and invalidate the current selection. */
	void keydb_push_found_state (KEYDB_HANDLE hd);

	/* Restore the previous save state. */
	void keydb_pop_found_state (KEYDB_HANDLE hd);

	/* Return the file name of the resource. */
	const char *keydb_get_resource_name (KEYDB_HANDLE hd);

	/* Return the keyblock last found by keydb_search. */
	gpg_error_t keydb_get_keyblock (KEYDB_HANDLE hd, KBNODE *ret_kb);

	/* Update the keyblock KB. */
	gpg_error_t keydb_update_keyblock (ctrl_t ctrl, KEYDB_HANDLE hd, kbnode_t kb);

	/* Insert a keyblock into one of the underlying keyrings or keyboxes. */
	gpg_error_t keydb_insert_keyblock (KEYDB_HANDLE hd, kbnode_t kb);

	/* Delete the currently selected keyblock. */
	gpg_error_t keydb_delete_keyblock (KEYDB_HANDLE hd);

	/* Find the first writable resource. */
	gpg_error_t keydb_locate_writable (KEYDB_HANDLE hd);

	/* Rebuild the on-disk caches of all key resources. */
	void keydb_rebuild_caches (ctrl_t ctrl, int noisy);

	/* Return the number of skipped blocks (because they were to large to
	read from a keybox) since the last search reset. */
	unsigned long keydb_get_skipped_counter (KEYDB_HANDLE hd);

	/* Clears the current search result and resets the handle's position. */
	gpg_error_t keydb_search_reset (KEYDB_HANDLE hd);

	/* Search the database for keys matching the search description. */
	gpg_error_t keydb_search (KEYDB_HANDLE hd, KEYDB_SEARCH_DESC *desc,
	size_t ndesc, size_t *descindex);

	/* Return the first non-legacy key in the database. */
	gpg_error_t keydb_search_first (KEYDB_HANDLE hd);

	/* Return the next key (not the next matching key!). */
	gpg_error_t keydb_search_next (KEYDB_HANDLE hd);

	/* This is a convenience function for searching for keys with a long
	key id. */
	gpg_error_t keydb_search_kid (KEYDB_HANDLE hd, u32 *kid);

	/* This is a convenience function for searching for keys by
	* fingerprint. */
	gpg_error_t keydb_search_fpr (KEYDB_HANDLE hd, const byte *fpr, size_t fprlen);


	/-- pkclist.c --/
	void show_revocation_reason (ctrl_t ctrl, PKT_public_key *pk, int mode );
	int check_signatures_trust (ctrl_t ctrl, PKT_signature *sig);

	void release_pk_list (PK_LIST pk_list);
	+int expand_id (const char id, strlist_t into, unsigned int flags);
	+strlist_t expand_group (strlist_t input);
	int build_pk_list (ctrl_t ctrl, strlist_t rcpts, PK_LIST *ret_pk_list);
	gpg_error_t find_and_check_key (ctrl_t ctrl,
	const char *name, unsigned int use,
	int mark_hidden, int from_file,
	pk_list_t *pk_list_addr);

	int algo_available( preftype_t preftype, int algo,
	const union pref_hint *hint );
	int select_algo_from_prefs( PK_LIST pk_list, int preftype,
	int request, const union pref_hint *hint);
	int select_mdc_from_pklist (PK_LIST pk_list);
	aead_algo_t select_aead_from_pklist (pk_list_t pk_list);
	void warn_missing_aead_from_pklist (PK_LIST pk_list);
	void warn_missing_aes_from_pklist (PK_LIST pk_list);

	/-- skclist.c --/
	int random_is_faked (void);
	void release_sk_list( SK_LIST sk_list );
	gpg_error_t build_sk_list (ctrl_t ctrl, strlist_t locusr,
	SK_LIST *ret_sk_list, unsigned use);

	/-- passphrase.h --/
	int have_static_passphrase(void);
	const char *get_static_passphrase (void);
	void set_passphrase_from_string(const char *pass);
	void read_passphrase_from_fd( int fd );
	void passphrase_clear_cache (const char *cacheid);
	DEK passphrase_to_dek_ext(u32 keyid, int pubkey_algo,
	int cipher_algo, STRING2KEY *s2k, int mode,
	const char *tryagain_text,
	const char custdesc, const char custprompt,
	int *canceled);
	DEK passphrase_to_dek (int cipher_algo, STRING2KEY s2k,
	int create, int nocache,
	const char tryagain_text, int canceled);
	void set_next_passphrase( const char *s );
	char *get_last_passphrase(void);
	void next_to_last_passphrase(void);

	void emit_status_need_passphrase (ctrl_t ctrl, u32 *keyid,
	u32 *mainkeyid, int pubkey_algo);

	#define FORMAT_KEYDESC_NORMAL 0
	#define FORMAT_KEYDESC_IMPORT 1
	#define FORMAT_KEYDESC_EXPORT 2
	#define FORMAT_KEYDESC_DELKEY 3
	char *gpg_format_keydesc (ctrl_t ctrl,
	PKT_public_key *pk, int mode, int escaped);


	/-- getkey.c --/

	/* Cache a copy of a public key in the public key cache. */
	void cache_public_key( PKT_public_key *pk );

	/* Disable and drop the public key cache. */
	void getkey_disable_caches(void);

	/* Return the public key used for signature SIG and store it at PK. */
	gpg_error_t get_pubkey_for_sig (ctrl_t ctrl,
	PKT_public_key pk, PKT_signature sig);

	/* Return the public key with the key id KEYID and store it at PK. */
	int get_pubkey (ctrl_t ctrl, PKT_public_key pk, u32 keyid);

	/* Similar to get_pubkey, but it does not take PK->REQ_USAGE into
	account nor does it merge in the self-signed data. This function
	also only considers primary keys. */
	int get_pubkey_fast (PKT_public_key pk, u32 keyid);

	/* Return the entire keyblock used to create SIG. This is a
	* specialized version of get_pubkeyblock. */
	kbnode_t get_pubkeyblock_for_sig (ctrl_t ctrl, PKT_signature *sig);

	/* Return the key block for the key with KEYID. */
	kbnode_t get_pubkeyblock (ctrl_t ctrl, u32 *keyid);

	/* A list used by get_pubkeys to gather all of the matches. */
	struct pubkey_s
	{
	struct pubkey_s *next;
	/* The key to use (either the public key or the subkey). */
	PKT_public_key *pk;
	kbnode_t keyblock;
	};
	typedef struct pubkey_s *pubkey_t;

	/* Free a list of public keys. */
	void pubkeys_free (pubkey_t keys);


	/* Mode flags for get_pubkey_byname. */
	enum get_pubkey_modes
	{
	GET_PUBKEY_NORMAL = 0,
	GET_PUBKEY_NO_AKL = 1,
	GET_PUBKEY_NO_LOCAL = 2
	};

	/* Find a public key identified by NAME. */
	int get_pubkey_byname (ctrl_t ctrl, enum get_pubkey_modes mode,
	GETKEY_CTX retctx, PKT_public_key pk,
	const char *name,
	KBNODE ret_keyblock, KEYDB_HANDLE ret_kdbhd,
	int include_unusable);

	/* Likewise, but only return the best match if NAME resembles a mail
	* address. */
	gpg_error_t get_best_pubkey_byname (ctrl_t ctrl, enum get_pubkey_modes mode,
	GETKEY_CTX retctx, PKT_public_key pk,
	const char name, KBNODE ret_keyblock,
	int include_unusable);

	/* Get a public key directly from file FNAME. */
	gpg_error_t get_pubkey_fromfile (ctrl_t ctrl,
	PKT_public_key pk, const char fname);

	/* Return the public key with the key id KEYID iff the secret key is
	* available and store it at PK. */
	gpg_error_t get_seckey (ctrl_t ctrl, PKT_public_key pk, u32 keyid);

	/* Lookup a key with the specified fingerprint. */
	int get_pubkey_byfprint (ctrl_t ctrl, PKT_public_key pk, kbnode_t r_keyblock,
	const byte *fprint, size_t fprint_len);

	/* This function is similar to get_pubkey_byfprint, but it doesn't
	merge the self-signed data into the public key and subkeys or into
	the user ids. */
	gpg_error_t get_pubkey_byfprint_fast (PKT_public_key *pk,
	const byte *fprint, size_t fprint_len);

	/* This function is similar to get_pubkey_byfprint, but it doesn't
	merge the self-signed data into the public key and subkeys or into
	the user ids. */
	gpg_error_t get_keyblock_byfprint_fast (kbnode_t *r_keyblock,
	KEYDB_HANDLE *r_hd,
	const byte *fprint, size_t fprint_len,
	int lock);


	/* Returns true if a secret key is available for the public key with
	key id KEYID. */
	int have_secret_key_with_kid (u32 *keyid);

	/* Parse the --default-key parameter. Returns the last key (in terms
	of when the option is given) that is available. */
	const char *parse_def_secret_key (ctrl_t ctrl);

	/* Look up a secret key. */
	gpg_error_t get_seckey_default (ctrl_t ctrl, PKT_public_key *pk);
	gpg_error_t get_seckey_default_or_card (ctrl_t ctrl, PKT_public_key *pk,
	const byte *fpr, size_t fpr_len);

	/* Search for keys matching some criteria. */
	gpg_error_t getkey_bynames (ctrl_t ctrl,
	getkey_ctx_t retctx, PKT_public_key pk,
	strlist_t names, int want_secret,
	kbnode_t *ret_keyblock);

	/* Search for one key matching some criteria. */
	gpg_error_t getkey_byname (ctrl_t ctrl,
	getkey_ctx_t retctx, PKT_public_key pk,
	const char *name, int want_secret,
	kbnode_t *ret_keyblock);

	/* Return the next search result. */
	gpg_error_t getkey_next (ctrl_t ctrl, getkey_ctx_t ctx,
	PKT_public_key pk, kbnode_t ret_keyblock);

	/* Release any resources used by a key listing context. */
	void getkey_end (ctrl_t ctrl, getkey_ctx_t ctx);

	/* Return the database handle used by this context. The context still
	owns the handle. */
	KEYDB_HANDLE get_ctx_handle(GETKEY_CTX ctx);

	/* Enumerate some secret keys. */
	gpg_error_t enum_secret_keys (ctrl_t ctrl, void *context, PKT_public_key pk);

	/* Set the mainkey_id fields for all keys in KEYBLOCK. */
	void setup_main_keyids (kbnode_t keyblock);

	/* This function merges information from the self-signed data into the
	data structures. */
	void merge_keys_and_selfsig (ctrl_t ctrl, kbnode_t keyblock);

	char get_user_id_string_native (ctrl_t ctrl, u32 keyid);
	char get_long_user_id_string (ctrl_t ctrl, u32 keyid);
	char get_user_id (ctrl_t ctrl, u32 keyid, size_t rn, int r_nouid);
	char get_user_id_native (ctrl_t ctrl, u32 keyid);
	char get_user_id_byfpr_native (ctrl_t ctrl, const byte fpr, size_t fprlen);

	void release_akl(void);
	int akl_empty_or_only_local (void);
	int parse_auto_key_locate(const char *options);
	int parse_key_origin (char *string);
	const char *key_origin_string (int origin);

	/-- keyid.c --/
	int pubkey_letter( int algo );
	char pubkey_string (PKT_public_key pk, char *buffer, size_t bufsize);
	#define PUBKEY_STRING_SIZE 32
	u32 v3_keyid (gcry_mpi_t a, u32 *ki);
	void hash_public_key( gcry_md_hd_t md, PKT_public_key *pk );
	char format_keyid (u32 keyid, int format, char *buffer, int len);

	/* Return PK's keyid. The memory is owned by PK. */
	u32 pk_keyid (PKT_public_key pk);

	/* Return the keyid of the primary key associated with PK. The memory
	is owned by PK. */
	u32 pk_main_keyid (PKT_public_key pk);

	/* Order A and B. If A < B then return -1, if A == B then return 0,
	and if A > B then return 1. */
	static int GPGRT_ATTR_UNUSED
	keyid_cmp (const u32 a, const u32 b)
	{
	if (a[0] < b[0])
	return -1;
	if (a[0] > b[0])
	return 1;
	if (a[1] < b[1])
	return -1;
	if (a[1] > b[1])
	return 1;
	return 0;
	}

	/* Return whether PK is a primary key. */
	static int GPGRT_ATTR_UNUSED
	pk_is_primary (PKT_public_key *pk)
	{
	return keyid_cmp (pk_keyid (pk), pk_main_keyid (pk)) == 0;
	}

	/* Copy the keyid in SRC to DEST and return DEST. */
	u32 keyid_copy (u32 dest, const u32 *src);

	size_t keystrlen(void);
	const char keystr(u32 keyid);
	const char keystr_with_sub (u32 main_kid, u32 *sub_kid);
	const char keystr_from_pk(PKT_public_key pk);
	const char keystr_from_pk_with_sub (PKT_public_key main_pk,
	PKT_public_key *sub_pk);

	/* Return PK's key id as a string using the default format. PK owns
	the storage. */
	const char pk_keyid_str (PKT_public_key pk);

	const char keystr_from_desc(KEYDB_SEARCH_DESC desc);
	u32 keyid_from_pk( PKT_public_key pk, u32 keyid );
	u32 keyid_from_sig (PKT_signature sig, u32 keyid );
	u32 keyid_from_fingerprint (ctrl_t ctrl, const byte *fprint, size_t fprint_len,
	u32 *keyid);
	byte namehash_from_uid(PKT_user_id uid);
	unsigned nbits_from_pk( PKT_public_key *pk );

	/* Convert an UTC TIMESTAMP into an UTC yyyy-mm-dd string. Return
	* that string. The caller should pass a buffer with at least a size
	* of MK_DATESTR_SIZE. */
	char mk_datestr (char buffer, size_t bufsize, u32 timestamp);
	#define MK_DATESTR_SIZE 11

	const char datestr_from_pk( PKT_public_key pk );
	const char datestr_from_sig( PKT_signature sig );
	const char expirestr_from_pk( PKT_public_key pk );
	const char expirestr_from_sig( PKT_signature sig );
	const char revokestr_from_pk( PKT_public_key pk );
	const char usagestr_from_pk (PKT_public_key pk, int fill);
	const char *colon_strtime (u32 t);
	const char colon_datestr_from_pk (PKT_public_key pk);
	const char colon_datestr_from_sig (PKT_signature sig);
	const char colon_expirestr_from_sig (PKT_signature sig);
	byte fingerprint_from_pk( PKT_public_key pk, byte buf, size_t ret_len );
	char hexfingerprint (PKT_public_key pk, char *buffer, size_t buflen);
	char format_hexfingerprint (const char fingerprint,
	char *buffer, size_t buflen);
	gpg_error_t keygrip_from_pk (PKT_public_key pk, unsigned char array);
	gpg_error_t hexkeygrip_from_pk (PKT_public_key pk, char *r_grip);


	/-- kbnode.c --/
	KBNODE new_kbnode( PACKET *pkt );
	KBNODE clone_kbnode( KBNODE node );
	void release_kbnode( KBNODE n );
	void delete_kbnode( KBNODE node );
	void add_kbnode( KBNODE root, KBNODE node );
	void insert_kbnode( KBNODE root, KBNODE node, int pkttype );
	void move_kbnode( KBNODE *root, KBNODE node, KBNODE where );
	void remove_kbnode( KBNODE *root, KBNODE node );
	KBNODE find_prev_kbnode( KBNODE root, KBNODE node, int pkttype );
	KBNODE find_next_kbnode( KBNODE node, int pkttype );
	KBNODE find_kbnode( KBNODE node, int pkttype );
	KBNODE walk_kbnode( KBNODE root, KBNODE *context, int all );
	void clear_kbnode_flags( KBNODE n );
	int commit_kbnode( KBNODE *root );
	void dump_kbnode( KBNODE node );

	#endif /G10_KEYDB_H/
	diff --git a/g10/pkclist.c b/g10/pkclist.c
	index 36ec4757e..996b3ba6e 100644
	--- a/g10/pkclist.c
	+++ b/g10/pkclist.c
	@@ -1,1722 +1,1673 @@
	/* pkclist.c - create a list of public keys
	* Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
	* 2008, 2009, 2010 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 <stdio.h>
	#include <stdlib.h>
	#include <string.h>
	#include <errno.h>

	#include "gpg.h"
	#include "options.h"
	#include "packet.h"
	#include "../common/status.h"
	#include "keydb.h"
	#include "../common/util.h"
	#include "main.h"
	#include "trustdb.h"
	#include "../common/ttyio.h"
	#include "../common/status.h"
	#include "photoid.h"
	#include "../common/i18n.h"
	#include "tofu.h"

	#define CONTROL_D ('D' - 'A' + 1)

	static void
	send_status_inv_recp (int reason, const char *name)
	{
	char buf[40];

	snprintf (buf, sizeof buf, "%d ", reason);
	write_status_text_and_buffer (STATUS_INV_RECP, buf,
	name, strlen (name),
	-1);
	}


	/****************
	* Show the revocation reason as it is stored with the given signature
	*/
	static void
	do_show_revocation_reason( PKT_signature *sig )
	{
	size_t n, nn;
	const byte p, pp;
	int seq = 0;
	const char *text;

	while ((p = enum_sig_subpkt (sig, 1, SIGSUBPKT_REVOC_REASON,
	&n, &seq, NULL)) ) {
	if( !n )
	continue; /* invalid - just skip it */

	if( *p == 0 )
	text = _("No reason specified");
	else if( *p == 0x01 )
	text = _("Key is superseded");
	else if( *p == 0x02 )
	text = _("Key has been compromised");
	else if( *p == 0x03 )
	text = _("Key is no longer used");
	else if( *p == 0x20 )
	text = _("User ID is no longer valid");
	else
	text = NULL;

	log_info ( _("reason for revocation: "));
	if (text)
	log_printf ("%s\n", text);
	else
	log_printf ("code=%02x\n", *p );
	n--; p++;
	pp = NULL;
	do {
	/* We don't want any empty lines, so skip them */
	while( n && *p == '\n' ) {
	p++;
	n--;
	}
	if( n ) {
	pp = memchr( p, '\n', n );
	nn = pp? pp - p : n;
	log_info ( _("revocation comment: ") );
	es_write_sanitized (log_get_stream(), p, nn, NULL, NULL);
	log_printf ("\n");
	p += nn; n -= nn;
	}
	} while( pp );
	}
	}

	/* Mode 0: try and find the revocation based on the pk (i.e. check
	subkeys, etc.) Mode 1: use only the revocation on the main pk */

	void
	show_revocation_reason (ctrl_t ctrl, PKT_public_key *pk, int mode)
	{
	/* Hmmm, this is not so easy because we have to duplicate the code
	* used in the trustdb to calculate the keyflags. We need to find
	* a clean way to check revocation certificates on keys and
	* signatures. And there should be no duplicate code. Because we
	* enter this function only when the trustdb told us that we have
	* a revoked key, we could simply look for a revocation cert and
	* display this one, when there is only one. Let's try to do this
	* until we have a better solution. */
	KBNODE node, keyblock = NULL;
	byte fingerprint[MAX_FINGERPRINT_LEN];
	size_t fingerlen;
	int rc;

	/* get the keyblock */
	fingerprint_from_pk( pk, fingerprint, &fingerlen );
	rc = get_pubkey_byfprint (ctrl, NULL, &keyblock, fingerprint, fingerlen);
	if( rc ) { /* that should never happen */
	log_debug( "failed to get the keyblock\n");
	return;
	}

	for( node=keyblock; node; node = node->next ) {
	if( (mode && node->pkt->pkttype == PKT_PUBLIC_KEY) \|\|
	( ( node->pkt->pkttype == PKT_PUBLIC_KEY
	\|\| node->pkt->pkttype == PKT_PUBLIC_SUBKEY )
	&& !cmp_public_keys( node->pkt->pkt.public_key, pk ) ) )
	break;
	}
	if( !node ) {
	log_debug("Oops, PK not in keyblock\n");
	release_kbnode( keyblock );
	return;
	}
	/* now find the revocation certificate */
	for( node = node->next; node ; node = node->next ) {
	if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY )
	break;
	if( node->pkt->pkttype == PKT_SIGNATURE
	&& (node->pkt->pkt.signature->sig_class == 0x20
	\|\| node->pkt->pkt.signature->sig_class == 0x28 ) ) {
	/* FIXME: we should check the signature here */
	do_show_revocation_reason ( node->pkt->pkt.signature );
	break;
	}
	}

	/* We didn't find it, so check if the whole key is revoked */
	if(!node && !mode)
	show_revocation_reason (ctrl, pk, 1);

	release_kbnode( keyblock );
	}


	/****************
	* mode: 0 = standard
	* 1 = Without key info and additional menu option 'm'
	* this does also add an option to set the key to ultimately trusted.
	* Returns:
	* -2 = nothing changed - caller should show some additional info
	* -1 = quit operation
	* 0 = nothing changed
	* 1 = new ownertrust now in new_trust
	*/
	#ifndef NO_TRUST_MODELS
	static int
	do_edit_ownertrust (ctrl_t ctrl, PKT_public_key *pk, int mode,
	unsigned *new_trust, int defer_help )
	{
	char *p;
	u32 keyid[2];
	int changed=0;
	int quit=0;
	int show=0;
	int min_num;
	int did_help=defer_help;
	unsigned int minimum = tdb_get_min_ownertrust (ctrl, pk, 0);

	switch(minimum)
	{
	default:
	case TRUST_UNDEFINED: min_num=1; break;
	case TRUST_NEVER: min_num=2; break;
	case TRUST_MARGINAL: min_num=3; break;
	case TRUST_FULLY: min_num=4; break;
	}

	keyid_from_pk (pk, keyid);
	for(;;) {
	/* A string with valid answers.

	TRANSLATORS: These are the allowed answers in lower and
	uppercase. Below you will find the matching strings which
	should be translated accordingly and the letter changed to
	match the one in the answer string.

	i = please show me more information
	m = back to the main menu
	s = skip this key
	q = quit
	*/
	const char *ans = _("iImMqQsS");

	if( !did_help )
	{
	if( !mode )
	{
	KBNODE keyblock, un;

	tty_printf (_("No trust value assigned to:\n"));
	print_key_line (ctrl, NULL, pk, 0);

	p = get_user_id_native (ctrl, keyid);
	tty_printf (_(" \"%s\"\n"),p);
	xfree (p);

	keyblock = get_pubkeyblock (ctrl, keyid);
	if (!keyblock)
	BUG ();
	for (un=keyblock; un; un = un->next)
	{
	if (un->pkt->pkttype != PKT_USER_ID )
	continue;
	if (un->pkt->pkt.user_id->flags.revoked)
	continue;
	if (un->pkt->pkt.user_id->flags.expired)
	continue;
	/* Only skip textual primaries */
	if (un->pkt->pkt.user_id->flags.primary
	&& !un->pkt->pkt.user_id->attrib_data )
	continue;

	if((opt.verify_options&VERIFY_SHOW_PHOTOS)
	&& un->pkt->pkt.user_id->attrib_data)
	show_photos (ctrl,
	un->pkt->pkt.user_id->attribs,
	un->pkt->pkt.user_id->numattribs, pk,
	un->pkt->pkt.user_id);

	p=utf8_to_native(un->pkt->pkt.user_id->name,
	un->pkt->pkt.user_id->len,0);

	tty_printf(_(" aka \"%s\"\n"),p);
	}

	print_fingerprint (ctrl, NULL, pk, 2);
	tty_printf("\n");
	release_kbnode (keyblock);
	}

	if(opt.trust_model==TM_DIRECT)
	{
	tty_printf(_("How much do you trust that this key actually "
	"belongs to the named user?\n"));
	tty_printf("\n");
	}
	else
	{
	/* This string also used in keyedit.c:trustsig_prompt */
	tty_printf(_("Please decide how far you trust this user to"
	" correctly verify other users' keys\n"
	"(by looking at passports, checking fingerprints from"
	" different sources, etc.)\n"));
	tty_printf("\n");
	}

	if(min_num<=1)
	tty_printf (_(" %d = I don't know or won't say\n"), 1);
	if(min_num<=2)
	tty_printf (_(" %d = I do NOT trust\n"), 2);
	if(min_num<=3)
	tty_printf (_(" %d = I trust marginally\n"), 3);
	if(min_num<=4)
	tty_printf (_(" %d = I trust fully\n"), 4);
	if (mode)
	tty_printf (_(" %d = I trust ultimately\n"), 5);
	#if 0
	/* not yet implemented */
	tty_printf (" i = please show me more information\n");
	#endif
	if( mode )
	tty_printf(_(" m = back to the main menu\n"));
	else
	{
	tty_printf(_(" s = skip this key\n"));
	tty_printf(_(" q = quit\n"));
	}
	tty_printf("\n");
	if(minimum)
	tty_printf(_("The minimum trust level for this key is: %s\n\n"),
	trust_value_to_string(minimum));
	did_help = 1;
	}
	if( strlen(ans) != 8 )
	BUG();
	p = cpr_get("edit_ownertrust.value",_("Your decision? "));
	trim_spaces(p);
	cpr_kill_prompt();
	if( !*p )
	did_help = 0;
	else if( *p && p[1] )
	;
	else if( !p[1] && ((p >= '0'+min_num) && p <= (mode?'5':'4')) )
	{
	unsigned int trust;
	switch( *p )
	{
	case '1': trust = TRUST_UNDEFINED; break;
	case '2': trust = TRUST_NEVER ; break;
	case '3': trust = TRUST_MARGINAL ; break;
	case '4': trust = TRUST_FULLY ; break;
	case '5': trust = TRUST_ULTIMATE ; break;
	default: BUG();
	}
	if (trust == TRUST_ULTIMATE
	&& !cpr_get_answer_is_yes ("edit_ownertrust.set_ultimate.okay",
	_("Do you really want to set this key"
	" to ultimate trust? (y/N) ")))
	; /* no */
	else
	{
	*new_trust = trust;
	changed = 1;
	break;
	}
	}
	#if 0
	/* not yet implemented */
	else if( p == ans[0] \|\| p == ans[1] )
	{
	tty_printf(_("Certificates leading to an ultimately trusted key:\n"));
	show = 1;
	break;
	}
	#endif
	else if( mode && (p == ans[2] \|\| p == ans[3] \|\| *p == CONTROL_D ) )
	{
	break ; /* back to the menu */
	}
	else if( !mode && (p == ans[6] \|\| p == ans[7] ) )
	{
	break; /* skip */
	}
	else if( !mode && (p == ans[4] \|\| p == ans[5] ) )
	{
	quit = 1;
	break ; /* back to the menu */
	}
	xfree(p); p = NULL;
	}
	xfree(p);
	return show? -2: quit? -1 : changed;
	}
	#endif /!NO_TRUST_MODELS/


	/*
	* Display a menu to change the ownertrust of the key PK (which should
	* be a primary key).
	* For mode values see do_edit_ownertrust ()
	*/
	#ifndef NO_TRUST_MODELS
	int
	edit_ownertrust (ctrl_t ctrl, PKT_public_key *pk, int mode )
	{
	unsigned int trust = 0;
	int no_help = 0;

	for(;;)
	{
	switch ( do_edit_ownertrust (ctrl, pk, mode, &trust, no_help ) )
	{
	case -1: /* quit */
	return -1;
	case -2: /* show info */
	no_help = 1;
	break;
	case 1: /* trust value set */
	trust &= ~TRUST_FLAG_DISABLED;
	trust \|= get_ownertrust (ctrl, pk) & TRUST_FLAG_DISABLED;
	update_ownertrust (ctrl, pk, trust );
	return 1;
	default:
	return 0;
	}
	}
	}
	#endif /!NO_TRUST_MODELS/


	/****************
	* Check whether we can trust this pk which has a trustlevel of TRUSTLEVEL
	* Returns: true if we trust.
	*/
	static int
	do_we_trust( PKT_public_key *pk, unsigned int trustlevel )
	{
	/* We should not be able to get here with a revoked or expired
	key */
	if(trustlevel & TRUST_FLAG_REVOKED
	\|\| trustlevel & TRUST_FLAG_SUB_REVOKED
	\|\| (trustlevel & TRUST_MASK) == TRUST_EXPIRED)
	BUG();

	if( opt.trust_model==TM_ALWAYS )
	{
	if( opt.verbose )
	log_info("No trust check due to '--trust-model always' option\n");
	return 1;
	}

	switch(trustlevel & TRUST_MASK)
	{
	default:
	log_error ("invalid trustlevel %u returned from validation layer\n",
	trustlevel);
	/* fall through */
	case TRUST_UNKNOWN:
	case TRUST_UNDEFINED:
	log_info(_("%s: There is no assurance this key belongs"
	" to the named user\n"),keystr_from_pk(pk));
	return 0; /* no */

	case TRUST_MARGINAL:
	log_info(_("%s: There is limited assurance this key belongs"
	" to the named user\n"),keystr_from_pk(pk));
	return 1; /* yes */

	case TRUST_FULLY:
	if( opt.verbose )
	log_info(_("This key probably belongs to the named user\n"));
	return 1; /* yes */

	case TRUST_ULTIMATE:
	if( opt.verbose )
	log_info(_("This key belongs to us\n"));
	return 1; /* yes */

	case TRUST_NEVER:
	/* This can be returned by TOFU, which can return negative
	assertions. */
	log_info(_("%s: This key is bad! It has been marked as untrusted!\n"),
	keystr_from_pk(pk));
	return 0; /* no */
	}

	return 1; /NOTREACHED/
	}


	/****************
	* wrapper around do_we_trust, so we can ask whether to use the
	* key anyway.
	*/
	static int
	do_we_trust_pre (ctrl_t ctrl, PKT_public_key *pk, unsigned int trustlevel )
	{
	int rc;

	rc = do_we_trust( pk, trustlevel );

	if( !opt.batch && !rc )
	{
	print_key_info (ctrl, NULL, 0, pk, 0);
	print_fingerprint (ctrl, NULL, pk, 2);
	tty_printf("\n");

	if ((trustlevel & TRUST_MASK) == TRUST_NEVER)
	tty_printf(
	_("This key is bad! It has been marked as untrusted! If you\n"
	"really know what you are doing, you may answer the next\n"
	"question with yes.\n"));
	else
	tty_printf(
	_("It is NOT certain that the key belongs to the person named\n"
	"in the user ID. If you really know what you are doing,\n"
	"you may answer the next question with yes.\n"));

	tty_printf("\n");


	if (is_status_enabled ())
	{
	u32 kid[2];
	char *hint_str;

	keyid_from_pk (pk, kid);
	hint_str = get_long_user_id_string (ctrl, kid);
	write_status_text ( STATUS_USERID_HINT, hint_str );
	xfree (hint_str);
	}

	if( cpr_get_answer_is_yes("untrusted_key.override",
	_("Use this key anyway? (y/N) ")) )
	rc = 1;

	/* Hmmm: Should we set a flag to tell the user about
	* his decision the next time he encrypts for this recipient?
	*/
	}

	return rc;
	}


	/* Write a TRUST_foo status line inclduing the validation model. */
	static void
	write_trust_status (int statuscode, int trustlevel)
	{
	#ifdef NO_TRUST_MODELS
	write_status (statuscode);
	#else /* NO_TRUST_MODELS */
	int tm;

	/* For the combined tofu+pgp method, we return the trust model which
	* was responsible for the trustlevel. */
	if (opt.trust_model == TM_TOFU_PGP)
	tm = (trustlevel & TRUST_FLAG_TOFU_BASED)? TM_TOFU : TM_PGP;
	else
	tm = opt.trust_model;
	write_status_strings (statuscode, "0 ", trust_model_string (tm), NULL);
	#endif /* NO_TRUST_MODELS */
	}


	/****************
	* Check whether we can trust this signature.
	* Returns an error code if we should not trust this signature.
	*/
	int
	check_signatures_trust (ctrl_t ctrl, PKT_signature *sig)
	{
	PKT_public_key pk = xmalloc_clear( sizeof pk );
	unsigned int trustlevel = TRUST_UNKNOWN;
	int rc=0;

	rc = get_pubkey_for_sig (ctrl, pk, sig);
	if (rc)
	{ /* this should not happen */
	log_error("Ooops; the key vanished - can't check the trust\n");
	rc = GPG_ERR_NO_PUBKEY;
	goto leave;
	}

	if ( opt.trust_model==TM_ALWAYS )
	{
	if( !opt.quiet )
	log_info(_("WARNING: Using untrusted key!\n"));
	if (opt.with_fingerprint)
	print_fingerprint (ctrl, NULL, pk, 1);
	goto leave;
	}

	if(pk->flags.maybe_revoked && !pk->flags.revoked)
	log_info(_("WARNING: this key might be revoked (revocation key"
	" not present)\n"));

	trustlevel = get_validity (ctrl, NULL, pk, NULL, sig, 1);

	if ( (trustlevel & TRUST_FLAG_REVOKED) )
	{
	write_status( STATUS_KEYREVOKED );
	if(pk->flags.revoked == 2)
	log_info(_("WARNING: This key has been revoked by its"
	" designated revoker!\n"));
	else
	log_info(_("WARNING: This key has been revoked by its owner!\n"));
	log_info(_(" This could mean that the signature is forged.\n"));
	show_revocation_reason (ctrl, pk, 0);
	}
	else if ((trustlevel & TRUST_FLAG_SUB_REVOKED) )
	{
	write_status( STATUS_KEYREVOKED );
	log_info(_("WARNING: This subkey has been revoked by its owner!\n"));
	show_revocation_reason (ctrl, pk, 0);
	}

	if ((trustlevel & TRUST_FLAG_DISABLED))
	log_info (_("Note: This key has been disabled.\n"));

	/* If we have PKA information adjust the trustlevel. */
	if (sig->pka_info && sig->pka_info->valid)
	{
	unsigned char fpr[MAX_FINGERPRINT_LEN];
	PKT_public_key *primary_pk;
	size_t fprlen;
	int okay;


	primary_pk = xmalloc_clear (sizeof *primary_pk);
	get_pubkey (ctrl, primary_pk, pk->main_keyid);
	fingerprint_from_pk (primary_pk, fpr, &fprlen);
	free_public_key (primary_pk);

	if ( fprlen == 20 && !memcmp (sig->pka_info->fpr, fpr, 20) )
	{
	okay = 1;
	write_status_text (STATUS_PKA_TRUST_GOOD, sig->pka_info->email);
	log_info (_("Note: Verified signer's address is '%s'\n"),
	sig->pka_info->email);
	}
	else
	{
	okay = 0;
	write_status_text (STATUS_PKA_TRUST_BAD, sig->pka_info->email);
	log_info (_("Note: Signer's address '%s' "
	"does not match DNS entry\n"), sig->pka_info->email);
	}

	switch ( (trustlevel & TRUST_MASK) )
	{
	case TRUST_UNKNOWN:
	case TRUST_UNDEFINED:
	case TRUST_MARGINAL:
	if (okay && opt.verify_options&VERIFY_PKA_TRUST_INCREASE)
	{
	trustlevel = ((trustlevel & ~TRUST_MASK) \| TRUST_FULLY);
	log_info (_("trustlevel adjusted to FULL"
	" due to valid PKA info\n"));
	}
	/* fall through */
	case TRUST_FULLY:
	if (!okay)
	{
	trustlevel = ((trustlevel & ~TRUST_MASK) \| TRUST_NEVER);
	log_info (_("trustlevel adjusted to NEVER"
	" due to bad PKA info\n"));
	}
	break;
	}
	}

	/* Now let the user know what up with the trustlevel. */
	switch ( (trustlevel & TRUST_MASK) )
	{
	case TRUST_EXPIRED:
	log_info(_("Note: This key has expired!\n"));
	print_fingerprint (ctrl, NULL, pk, 1);
	break;

	default:
	log_error ("invalid trustlevel %u returned from validation layer\n",
	trustlevel);
	/* fall through */
	case TRUST_UNKNOWN:
	case TRUST_UNDEFINED:
	write_trust_status (STATUS_TRUST_UNDEFINED, trustlevel);
	log_info(_("WARNING: This key is not certified with"
	" a trusted signature!\n"));
	log_info(_(" There is no indication that the "
	"signature belongs to the owner.\n" ));
	print_fingerprint (ctrl, NULL, pk, 1);
	break;

	case TRUST_NEVER:
	/* This level can be returned by TOFU, which supports negative
	* assertions. */
	write_trust_status (STATUS_TRUST_NEVER, trustlevel);
	log_info(_("WARNING: We do NOT trust this key!\n"));
	log_info(_(" The signature is probably a FORGERY.\n"));
	if (opt.with_fingerprint)
	print_fingerprint (ctrl, NULL, pk, 1);
	rc = gpg_error (GPG_ERR_BAD_SIGNATURE);
	break;

	case TRUST_MARGINAL:
	write_trust_status (STATUS_TRUST_MARGINAL, trustlevel);
	log_info(_("WARNING: This key is not certified with"
	" sufficiently trusted signatures!\n"));
	log_info(_(" It is not certain that the"
	" signature belongs to the owner.\n" ));
	print_fingerprint (ctrl, NULL, pk, 1);
	break;

	case TRUST_FULLY:
	write_trust_status (STATUS_TRUST_FULLY, trustlevel);
	if (opt.with_fingerprint)
	print_fingerprint (ctrl, NULL, pk, 1);
	break;

	case TRUST_ULTIMATE:
	write_trust_status (STATUS_TRUST_ULTIMATE, trustlevel);
	if (opt.with_fingerprint)
	print_fingerprint (ctrl, NULL, pk, 1);
	break;
	}

	leave:
	free_public_key( pk );
	return rc;
	}


	void
	release_pk_list (pk_list_t pk_list)
	{
	PK_LIST pk_rover;

	for ( ; pk_list; pk_list = pk_rover)
	{
	pk_rover = pk_list->next;
	free_public_key ( pk_list->pk );
	xfree ( pk_list );
	}
	}


	static int
	key_present_in_pk_list(PK_LIST pk_list, PKT_public_key *pk)
	{
	for( ; pk_list; pk_list = pk_list->next)
	if (cmp_public_keys(pk_list->pk, pk) == 0)
	return 0;

	return -1;
	}


	/*
	* Return a malloced string with a default recipient if there is any
	* Fixme: We don't distinguish between malloc failure and no-default-recipient.
	*/
	static char *
	default_recipient (ctrl_t ctrl)
	{
	PKT_public_key *pk;
	char *result;

	if (opt.def_recipient)
	return xtrystrdup (opt.def_recipient);

	if (!opt.def_recipient_self)
	return NULL;
	pk = xtrycalloc (1, sizeof *pk );
	if (!pk)
	return NULL;
	if (get_seckey_default (ctrl, pk))
	{
	free_public_key (pk);
	return NULL;
	}
	result = hexfingerprint (pk, NULL, 0);
	free_public_key (pk);
	return result;
	}


	-static int
	-expand_id(const char id,strlist_t into,unsigned int flags)
	-{
	- struct groupitem *groups;
	- int count=0;
	-
	- for(groups=opt.grouplist;groups;groups=groups->next)
	- {
	- /* need strcasecmp() here, as this should be localized */
	- if(strcasecmp(groups->name,id)==0)
	- {
	- strlist_t each,sl;
	-
	- /* this maintains the current utf8-ness */
	- for(each=groups->values;each;each=each->next)
	- {
	- sl=add_to_strlist(into,each->d);
	- sl->flags=flags;
	- count++;
	- }
	-
	- break;
	- }
	- }
	-
	- return count;
	-}
	-
	-/* For simplicity, and to avoid potential loops, we only expand once -
	- * you can't make an alias that points to an alias. */
	-static strlist_t
	-expand_group (strlist_t input)
	-{
	- strlist_t output = NULL;
	- strlist_t sl, rover;
	-
	- for (rover = input; rover; rover = rover->next)
	- if (!(rover->flags & PK_LIST_FROM_FILE)
	- && !expand_id(rover->d,&output,rover->flags))
	- {
	- /* Didn't find any groups, so use the existing string */
	- sl=add_to_strlist(&output,rover->d);
	- sl->flags=rover->flags;
	- }
	-
	- return output;
	-}
	-
	-
	/* Helper for build_pk_list to find and check one key. This helper is
	* also used directly in server mode by the RECIPIENTS command. On
	* success the new key is added to PK_LIST_ADDR. NAME is the user id
	* of the key. USE the requested usage and a set MARK_HIDDEN will
	* mark the key in the updated list as a hidden recipient. If
	* FROM_FILE is true, NAME is not a user ID but the name of a file
	* holding a key. */
	gpg_error_t
	find_and_check_key (ctrl_t ctrl, const char *name, unsigned int use,
	int mark_hidden, int from_file, pk_list_t *pk_list_addr)
	{
	int rc;
	PKT_public_key *pk;
	KBNODE keyblock = NULL;

	if (!name \|\| !*name)
	return gpg_error (GPG_ERR_INV_USER_ID);

	pk = xtrycalloc (1, sizeof *pk);
	if (!pk)
	return gpg_error_from_syserror ();
	pk->req_usage = use;

	if (from_file)
	rc = get_pubkey_fromfile (ctrl, pk, name);
	else
	rc = get_best_pubkey_byname (ctrl, GET_PUBKEY_NORMAL,
	NULL, pk, name, &keyblock, 0);
	if (rc)
	{
	int code;

	/* Key not found or other error. */
	log_error (_("%s: skipped: %s\n"), name, gpg_strerror (rc) );
	switch (gpg_err_code (rc))
	{
	case GPG_ERR_NO_SECKEY:
	case GPG_ERR_NO_PUBKEY: code = 1; break;
	case GPG_ERR_INV_USER_ID: code = 14; break;
	default: code = 0; break;
	}
	send_status_inv_recp (code, name);
	free_public_key (pk);
	return rc;
	}

	rc = openpgp_pk_test_algo2 (pk->pubkey_algo, use);
	if (rc)
	{
	/* Key found but not usable for us (e.g. sign-only key). */
	release_kbnode (keyblock);
	send_status_inv_recp (3, name); /* Wrong key usage */
	log_error (_("%s: skipped: %s\n"), name, gpg_strerror (rc) );
	free_public_key (pk);
	return rc;
	}

	/* Key found and usable. Check validity. */
	if (!from_file)
	{
	int trustlevel;

	trustlevel = get_validity (ctrl, keyblock, pk, pk->user_id, NULL, 1);
	release_kbnode (keyblock);
	if ( (trustlevel & TRUST_FLAG_DISABLED) )
	{
	/* Key has been disabled. */
	send_status_inv_recp (13, name);
	log_info (_("%s: skipped: public key is disabled\n"), name);
	free_public_key (pk);
	return GPG_ERR_UNUSABLE_PUBKEY;
	}

	if ( !do_we_trust_pre (ctrl, pk, trustlevel) )
	{
	/* We don't trust this key. */
	send_status_inv_recp (10, name);
	free_public_key (pk);
	return GPG_ERR_UNUSABLE_PUBKEY;
	}
	}

	/* Skip the actual key if the key is already present in the
	list. */
	if (!key_present_in_pk_list (*pk_list_addr, pk))
	{
	if (!opt.quiet)
	log_info (_("%s: skipped: public key already present\n"), name);
	free_public_key (pk);
	}
	else
	{
	pk_list_t r;

	r = xtrymalloc (sizeof *r);
	if (!r)
	{
	rc = gpg_error_from_syserror ();
	free_public_key (pk);
	return rc;
	}
	r->pk = pk;
	r->next = *pk_list_addr;
	r->flags = mark_hidden? 1:0;
	*pk_list_addr = r;
	}

	return 0;
	}



	/* This is the central function to collect the keys for recipients.
	* It is thus used to prepare a public key encryption. encrypt-to
	* keys, default keys and the keys for the actual recipients are all
	* collected here. When not in batch mode and no recipient has been
	* passed on the commandline, the function will also ask for
	* recipients.
	*
	* RCPTS is a string list with the recipients; NULL is an allowed
	* value but not very useful. Group expansion is done on these names;
	* they may be in any of the user Id formats we can handle. The flags
	* bits for each string in the string list are used for:
	*
	* - PK_LIST_ENCRYPT_TO :: This is an encrypt-to recipient.
	* - PK_LIST_HIDDEN :: This is a hidden recipient.
	* - PK_LIST_FROM_FILE :: The argument is a file with a key.
	*
	* On success a list of keys is stored at the address RET_PK_LIST; the
	* caller must free this list. On error the value at this address is
	* not changed.
	*/
	int
	build_pk_list (ctrl_t ctrl, strlist_t rcpts, PK_LIST *ret_pk_list)
	{
	PK_LIST pk_list = NULL;
	PKT_public_key *pk=NULL;
	int rc=0;
	int any_recipients=0;
	strlist_t rov,remusr;
	char *def_rec = NULL;
	char pkstrbuf[PUBKEY_STRING_SIZE];

	/* Try to expand groups if any have been defined. */
	if (opt.grouplist)
	remusr = expand_group (rcpts);
	else
	remusr = rcpts;

	/* XXX: Change this function to use get_pubkeys instead of
	get_pubkey_byname to detect ambiguous key specifications and warn
	about duplicate keyblocks. For ambiguous key specifications on
	the command line or provided interactively, prompt the user to
	select the best key. If a key specification is ambiguous and we
	are in batch mode, die. */

	if (opt.encrypt_to_default_key)
	{
	static int warned;

	const char *default_key = parse_def_secret_key (ctrl);
	if (default_key)
	{
	PK_LIST r = xmalloc_clear (sizeof *r);

	r->pk = xmalloc_clear (sizeof *r->pk);
	r->pk->req_usage = PUBKEY_USAGE_ENC;

	rc = get_pubkey_byname (ctrl, GET_PUBKEY_NO_AKL,
	NULL, r->pk, default_key, NULL, NULL, 0);
	if (rc)
	{
	xfree (r->pk);
	xfree (r);

	log_error (_("can't encrypt to '%s'\n"), default_key);
	if (!opt.quiet)
	log_info (_("(check argument of option '%s')\n"),
	"--default-key");
	}
	else
	{
	r->next = pk_list;
	r->flags = 0;
	pk_list = r;
	}
	}
	else if (opt.def_secret_key)
	{
	if (! warned)
	log_info (_("option '%s' given, but no valid default keys given\n"),
	"--encrypt-to-default-key");
	warned = 1;
	}
	else
	{
	if (! warned)
	log_info (_("option '%s' given, but option '%s' not given\n"),
	"--encrypt-to-default-key", "--default-key");
	warned = 1;
	}
	}

	/* Check whether there are any recipients in the list and build the
	* list of the encrypt-to ones (we always trust them). */
	for ( rov = remusr; rov; rov = rov->next )
	{
	if ( !(rov->flags & PK_LIST_ENCRYPT_TO) )
	{
	/* This is a regular recipient; i.e. not an encrypt-to
	one. */
	any_recipients = 1;

	/* Hidden recipients are not allowed while in PGP mode,
	issue a warning and switch into GnuPG mode. */
	if ((rov->flags & PK_LIST_HIDDEN) && (PGP7 \|\| PGP8))
	{
	log_info(_("option '%s' may not be used in %s mode\n"),
	"--hidden-recipient",
	gnupg_compliance_option_string (opt.compliance));

	compliance_failure();
	}
	}
	else if (!opt.no_encrypt_to)
	{
	/* --encrypt-to has not been disabled. Check this
	encrypt-to key. */
	pk = xmalloc_clear( sizeof *pk );
	pk->req_usage = PUBKEY_USAGE_ENC;

	/* We explicitly allow encrypt-to to an disabled key; thus
	we pass 1 for the second last argument and 1 as the last
	argument to disable AKL. */
	if ((rc = get_pubkey_byname (ctrl, GET_PUBKEY_NO_AKL,
	NULL, pk, rov->d, NULL, NULL, 1)))
	{
	free_public_key ( pk ); pk = NULL;
	log_error (_("%s: skipped: %s\n"), rov->d, gpg_strerror (rc) );
	send_status_inv_recp (0, rov->d);
	goto fail;
	}
	else if ( !(rc=openpgp_pk_test_algo2 (pk->pubkey_algo,
	PUBKEY_USAGE_ENC)) )
	{
	/* Skip the actual key if the key is already present
	* in the list. Add it to our list if not. */
	if (key_present_in_pk_list(pk_list, pk) == 0)
	{
	free_public_key (pk); pk = NULL;
	if (!opt.quiet)
	log_info (_("%s: skipped: public key already present\n"),
	rov->d);
	}
	else
	{
	PK_LIST r;
	r = xmalloc( sizeof *r );
	r->pk = pk; pk = NULL;
	r->next = pk_list;
	r->flags = (rov->flags&PK_LIST_HIDDEN)?1:0;
	pk_list = r;

	/* Hidden encrypt-to recipients are not allowed while
	in PGP mode, issue a warning and switch into
	GnuPG mode. */
	if ((r->flags&PK_LIST_ENCRYPT_TO) && (PGP7 \|\| PGP8))
	{
	log_info(_("option '%s' may not be used in %s mode\n"),
	"--hidden-encrypt-to",
	gnupg_compliance_option_string (opt.compliance));

	compliance_failure();
	}
	}
	}
	else
	{
	/* The public key is not usable for encryption. */
	free_public_key( pk ); pk = NULL;
	log_error(_("%s: skipped: %s\n"), rov->d, gpg_strerror (rc) );
	send_status_inv_recp (3, rov->d); /* Wrong key usage */
	goto fail;
	}
	}
	}

	/* If we don't have any recipients yet and we are not in batch mode
	drop into interactive selection mode. */
	if ( !any_recipients && !opt.batch )
	{
	int have_def_rec;
	char *answer = NULL;
	strlist_t backlog = NULL;

	if (pk_list)
	any_recipients = 1;
	def_rec = default_recipient(ctrl);
	have_def_rec = !!def_rec;
	if ( !have_def_rec )
	tty_printf(_("You did not specify a user ID. (you may use \"-r\")\n"));

	for (;;)
	{
	rc = 0;
	xfree(answer);
	if ( have_def_rec )
	{
	/* A default recipient is taken as the first entry. */
	answer = def_rec;
	def_rec = NULL;
	}
	else if (backlog)
	{
	/* This is part of our trick to expand and display groups. */
	answer = strlist_pop (&backlog);
	}
	else
	{
	/* Show the list of already collected recipients and ask
	for more. */
	PK_LIST iter;

	tty_printf("\n");
	tty_printf(_("Current recipients:\n"));
	for (iter=pk_list;iter;iter=iter->next)
	{
	u32 keyid[2];

	keyid_from_pk(iter->pk,keyid);
	tty_printf ("%s/%s %s \"",
	pubkey_string (iter->pk,
	pkstrbuf, sizeof pkstrbuf),
	keystr(keyid),
	datestr_from_pk (iter->pk));

	if (iter->pk->user_id)
	tty_print_utf8_string(iter->pk->user_id->name,
	iter->pk->user_id->len);
	else
	{
	size_t n;
	char *p = get_user_id (ctrl, keyid, &n, NULL);
	tty_print_utf8_string ( p, n );
	xfree(p);
	}
	tty_printf("\"\n");
	}

	answer = cpr_get_utf8("pklist.user_id.enter",
	_("\nEnter the user ID. "
	"End with an empty line: "));
	trim_spaces(answer);
	cpr_kill_prompt();
	}

	if ( !answer \|\| !*answer )
	{
	xfree(answer);
	break; /* No more recipients entered - get out of loop. */
	}

	/* Do group expand here too. The trick here is to continue
	the loop if any expansion occurred. The code above will
	then list all expanded keys. */
	if (expand_id(answer,&backlog,0))
	continue;

	/* Get and check key for the current name. */
	free_public_key (pk);
	pk = xmalloc_clear( sizeof *pk );
	pk->req_usage = PUBKEY_USAGE_ENC;
	rc = get_pubkey_byname (ctrl, GET_PUBKEY_NORMAL,
	NULL, pk, answer, NULL, NULL, 0);
	if (rc)
	tty_printf(_("No such user ID.\n"));
	else if ( !(rc=openpgp_pk_test_algo2 (pk->pubkey_algo,
	PUBKEY_USAGE_ENC)) )
	{
	if ( have_def_rec )
	{
	/* No validation for a default recipient. */
	if (!key_present_in_pk_list(pk_list, pk))
	{
	free_public_key (pk);
	pk = NULL;
	log_info (_("skipped: public key "
	"already set as default recipient\n") );
	}
	else
	{
	PK_LIST r = xmalloc (sizeof *r);
	r->pk = pk; pk = NULL;
	r->next = pk_list;
	r->flags = 0; /* No throwing default ids. */
	pk_list = r;
	}
	any_recipients = 1;
	continue;
	}
	else
	{ /* Check validity of this key. */
	int trustlevel;

	trustlevel =
	get_validity (ctrl, NULL, pk, pk->user_id, NULL, 1);
	if ( (trustlevel & TRUST_FLAG_DISABLED) )
	{
	tty_printf (_("Public key is disabled.\n") );
	}
	else if ( do_we_trust_pre (ctrl, pk, trustlevel) )
	{
	/* Skip the actual key if the key is already
	* present in the list */
	if (!key_present_in_pk_list(pk_list, pk))
	{
	free_public_key (pk);
	pk = NULL;
	log_info(_("skipped: public key already set\n") );
	}
	else
	{
	PK_LIST r;
	r = xmalloc( sizeof *r );
	r->pk = pk; pk = NULL;
	r->next = pk_list;
	r->flags = 0; /* No throwing interactive ids. */
	pk_list = r;
	}
	any_recipients = 1;
	continue;
	}
	}
	}
	xfree(def_rec); def_rec = NULL;
	have_def_rec = 0;
	}
	if ( pk )
	{
	free_public_key( pk );
	pk = NULL;
	}
	}
	else if ( !any_recipients && (def_rec = default_recipient(ctrl)) )
	{
	/* We are in batch mode and have only a default recipient. */
	pk = xmalloc_clear( sizeof *pk );
	pk->req_usage = PUBKEY_USAGE_ENC;

	/* The default recipient is allowed to be disabled; thus pass 1
	as second last argument. We also don't want an AKL. */
	rc = get_pubkey_byname (ctrl, GET_PUBKEY_NO_AKL,
	NULL, pk, def_rec, NULL, NULL, 1);
	if (rc)
	log_error(_("unknown default recipient \"%s\"\n"), def_rec );
	else if ( !(rc=openpgp_pk_test_algo2(pk->pubkey_algo,
	PUBKEY_USAGE_ENC)) )
	{
	/* Mark any_recipients here since the default recipient
	would have been used if it wasn't already there. It
	doesn't really matter if we got this key from the default
	recipient or an encrypt-to. */
	any_recipients = 1;
	if (!key_present_in_pk_list(pk_list, pk))
	log_info (_("skipped: public key already set "
	"as default recipient\n"));
	else
	{
	PK_LIST r = xmalloc( sizeof *r );
	r->pk = pk; pk = NULL;
	r->next = pk_list;
	r->flags = 0; /* No throwing default ids. */
	pk_list = r;
	}
	}
	if ( pk )
	{
	free_public_key( pk );
	pk = NULL;
	}
	xfree(def_rec); def_rec = NULL;
	}
	else
	{
	/* General case: Check all keys. */
	any_recipients = 0;
	for (; remusr; remusr = remusr->next )
	{
	if ( (remusr->flags & PK_LIST_ENCRYPT_TO) )
	continue; /* encrypt-to keys are already handled. */

	rc = find_and_check_key (ctrl, remusr->d, PUBKEY_USAGE_ENC,
	!!(remusr->flags&PK_LIST_HIDDEN),
	!!(remusr->flags&PK_LIST_FROM_FILE),
	&pk_list);
	if (rc)
	goto fail;
	any_recipients = 1;
	}
	}

	if ( !rc && !any_recipients )
	{
	log_error(_("no valid addressees\n"));
	write_status_text (STATUS_NO_RECP, "0");
	rc = GPG_ERR_NO_USER_ID;
	}

	#ifdef USE_TOFU
	if (! rc && (opt.trust_model == TM_TOFU_PGP \|\| opt.trust_model == TM_TOFU))
	{
	PK_LIST iter;
	for (iter = pk_list; iter; iter = iter->next)
	{
	int rc2;

	/* Note: we already resolved any conflict when looking up
	the key. Don't annoy the user again if she selected
	accept once. */
	rc2 = tofu_register_encryption (ctrl, iter->pk, NULL, 0);
	if (rc2)
	log_info ("WARNING: Failed to register encryption to %s"
	" with TOFU engine\n",
	keystr (pk_main_keyid (iter->pk)));
	else if (DBG_TRUST)
	log_debug ("Registered encryption to %s with TOFU DB.\n",
	keystr (pk_main_keyid (iter->pk)));
	}
	}
	#endif /USE_TOFU/

	fail:

	if ( rc )
	release_pk_list( pk_list );
	else
	*ret_pk_list = pk_list;
	if (opt.grouplist)
	free_strlist(remusr);
	return rc;
	}


	/* In pgp6 mode, disallow all ciphers except IDEA (1), 3DES (2), and
	CAST5 (3), all hashes except MD5 (1), SHA1 (2), and RIPEMD160 (3),
	and all compressions except none (0) and ZIP (1). pgp7 and pgp8
	mode expands the cipher list to include AES128 (7), AES192 (8),
	AES256 (9), and TWOFISH (10). pgp8 adds the SHA-256 hash (8). For
	a true PGP key all of this is unneeded as they are the only items
	present in the preferences subpacket, but checking here covers the
	weird case of encrypting to a key that had preferences from a
	different implementation which was then used with PGP. I am not
	completely comfortable with this as the right thing to do, as it
	slightly alters the list of what the user is supposedly requesting.
	It is not against the RFC however, as the preference chosen will
	never be one that the user didn't specify somewhere ("The
	implementation may use any mechanism to pick an algorithm in the
	intersection"), and PGP has no mechanism to fix such a broken
	preference list, so I'm including it. -dms */

	int
	algo_available( preftype_t preftype, int algo, const union pref_hint *hint)
	{
	if( preftype == PREFTYPE_SYM )
	{
	if(PGP7 && (algo != CIPHER_ALGO_IDEA
	&& algo != CIPHER_ALGO_3DES
	&& algo != CIPHER_ALGO_CAST5
	&& algo != CIPHER_ALGO_AES
	&& algo != CIPHER_ALGO_AES192
	&& algo != CIPHER_ALGO_AES256
	&& algo != CIPHER_ALGO_TWOFISH))
	return 0;

	/* PGP8 supports all the ciphers we do.. */

	return algo && !openpgp_cipher_test_algo ( algo );
	}
	else if( preftype == PREFTYPE_HASH )
	{
	if (hint && hint->digest_length)
	{
	if (hint->digest_length!=20 \|\| opt.flags.dsa2)
	{
	/* If --enable-dsa2 is set or the hash isn't 160 bits
	(which implies DSA2), then we'll accept a hash that
	is larger than we need. Otherwise we won't accept
	any hash that isn't exactly the right size. */
	if (hint->digest_length > gcry_md_get_algo_dlen (algo))
	return 0;
	}
	else if (hint->digest_length != gcry_md_get_algo_dlen (algo))
	return 0;
	}

	if (PGP7 && (algo != DIGEST_ALGO_MD5
	&& algo != DIGEST_ALGO_SHA1
	&& algo != DIGEST_ALGO_RMD160))
	return 0;


	if(PGP8 && (algo != DIGEST_ALGO_MD5
	&& algo != DIGEST_ALGO_SHA1
	&& algo != DIGEST_ALGO_RMD160
	&& algo != DIGEST_ALGO_SHA256))
	return 0;

	return algo && !openpgp_md_test_algo (algo);
	}
	else if( preftype == PREFTYPE_ZIP )
	{
	if (PGP7 && (algo != COMPRESS_ALGO_NONE
	&& algo != COMPRESS_ALGO_ZIP))
	return 0;

	/* PGP8 supports all the compression algos we do */

	return !check_compress_algo( algo );
	}
	else
	return 0;
	}

	/****************
	* Return -1 if we could not find an algorithm.
	*/
	int
	select_algo_from_prefs(PK_LIST pk_list, int preftype,
	int request, const union pref_hint *hint)
	{
	PK_LIST pkr;
	u32 bits[8];
	const prefitem_t *prefs;
	int result=-1,i;
	u16 scores[256];

	if( !pk_list )
	return -1;

	memset(bits,0xFF,sizeof(bits));
	memset(scores,0,sizeof(scores));

	for( pkr = pk_list; pkr; pkr = pkr->next )
	{
	u32 mask[8];
	int rank=1,implicit=-1;

	memset(mask,0,sizeof(mask));

	switch(preftype)
	{
	case PREFTYPE_SYM:
	/* IDEA is implicitly there for v3 keys with v3 selfsigs if
	--pgp2 mode is on. This was a 2440 thing that was
	dropped from 4880 but is still relevant to GPG's 1991
	support. All this doesn't mean IDEA is actually
	available, of course. */
	implicit=CIPHER_ALGO_3DES;
	break;

	case PREFTYPE_AEAD:
	/* No implicit algo. */
	break;

	case PREFTYPE_HASH:
	/* While I am including this code for completeness, note
	that currently --pgp2 mode locks the hash at MD5, so this
	code will never even be called. Even if the hash wasn't
	locked at MD5, we don't support sign+encrypt in --pgp2
	mode, and that's the only time PREFTYPE_HASH is used
	anyway. -dms */

	implicit=DIGEST_ALGO_SHA1;

	break;

	case PREFTYPE_ZIP:
	/* Uncompressed is always an option. */
	implicit=COMPRESS_ALGO_NONE;
	}

	if (pkr->pk->user_id) /* selected by user ID */
	prefs = pkr->pk->user_id->prefs;
	else
	prefs = pkr->pk->prefs;

	if( prefs )
	{
	for (i=0; prefs[i].type; i++ )
	{
	if( prefs[i].type == preftype )
	{
	/* Make sure all scores don't add up past 0xFFFF
	(and roll around) */
	if(rank+scores[prefs[i].value]<=0xFFFF)
	scores[prefs[i].value]+=rank;
	else
	scores[prefs[i].value]=0xFFFF;

	mask[prefs[i].value/32] \|= 1<<(prefs[i].value%32);

	rank++;

	/* We saw the implicit algorithm, so we don't need
	tack it on the end ourselves. */
	if(implicit==prefs[i].value)
	implicit=-1;
	}
	}
	}

	if(rank==1 && preftype==PREFTYPE_ZIP)
	{
	/* If the compression preferences are not present, they are
	assumed to be ZIP, Uncompressed (RFC4880:13.3.1) */
	scores[1]=1; /* ZIP is first choice */
	scores[0]=2; /* Uncompressed is second choice */
	mask[0]\|=3;
	}

	/* If the key didn't have the implicit algorithm listed
	explicitly, add it here at the tail of the list. */
	if(implicit>-1)
	{
	scores[implicit]+=rank;
	mask[implicit/32] \|= 1<<(implicit%32);
	}

	for(i=0;i<8;i++)
	bits[i]&=mask[i];
	}

	/* We've now scored all of the algorithms, and the usable ones have
	bits set. Let's pick the winner. */

	/* The caller passed us a request. Can we use it? */
	if(request>-1 && (bits[request/32] & (1<<(request%32))) &&
	algo_available(preftype,request,hint))
	result=request;

	if(result==-1)
	{
	/* If we have personal prefs set, use them. */
	prefs=NULL;
	if(preftype==PREFTYPE_SYM && opt.personal_cipher_prefs)
	prefs=opt.personal_cipher_prefs;
	else if(preftype==PREFTYPE_AEAD && opt.personal_aead_prefs)
	prefs=opt.personal_aead_prefs;
	else if(preftype==PREFTYPE_HASH && opt.personal_digest_prefs)
	prefs=opt.personal_digest_prefs;
	else if(preftype==PREFTYPE_ZIP && opt.personal_compress_prefs)
	prefs=opt.personal_compress_prefs;

	if( prefs )
	for(i=0; prefs[i].type; i++ )
	{
	if(bits[prefs[i].value/32] & (1<<(prefs[i].value%32))
	&& algo_available( preftype, prefs[i].value, hint))
	{
	result = prefs[i].value;
	break;
	}
	}
	}

	if(result==-1)
	{
	unsigned int best=-1;

	/* At this point, we have not selected an algorithm due to a
	special request or via personal prefs. Pick the highest
	ranked algorithm (i.e. the one with the lowest score). */

	if(preftype==PREFTYPE_HASH && scores[DIGEST_ALGO_MD5])
	{
	/* "If you are building an authentication system, the recipient
	may specify a preferred signing algorithm. However, the
	signer would be foolish to use a weak algorithm simply
	because the recipient requests it." (RFC4880:14). If any
	other hash algorithm is available, pretend that MD5 isn't.
	Note that if the user intentionally chose MD5 by putting it
	in their personal prefs, then we do what the user said (as we
	never reach this code). */

	for(i=DIGEST_ALGO_MD5+1;i<256;i++)
	if(scores[i])
	{
	scores[DIGEST_ALGO_MD5]=0;
	break;
	}
	}

	for(i=0;i<256;i++)
	{
	/* Note the '<' here. This means in case of a tie, we will
	favor the lower algorithm number. We have a choice
	between the lower number (probably an older algorithm
	with more time in use), or the higher number (probably a
	newer algorithm with less time in use). Older is
	probably safer here, even though the newer algorithms
	tend to be "stronger". */
	if(scores[i] && scores[i]<best
	&& (bits[i/32] & (1<<(i%32)))
	&& algo_available(preftype,i,hint))
	{
	best=scores[i];
	result=i;
	}
	}
	}

	return result;
	}

	/*
	* Select the MDC flag from the pk_list. We can only use MDC if all
	* recipients support this feature.
	*/
	int
	select_mdc_from_pklist (PK_LIST pk_list)
	{
	PK_LIST pkr;

	if ( !pk_list )
	return 0;

	for (pkr = pk_list; pkr; pkr = pkr->next)
	{
	int mdc;

	if (pkr->pk->user_id) /* selected by user ID */
	mdc = pkr->pk->user_id->flags.mdc;
	else
	mdc = pkr->pk->flags.mdc;
	if (!mdc)
	return 0; /* At least one recipient does not support it. */
	}
	return 1; /* Can be used. */
	}


	/* Select the AEAD flag from the pk_list. We can only use AEAD if all
	* recipients support this feature. Returns the AEAD to be used or 0
	* if AEAD shall not be used. */
	aead_algo_t
	select_aead_from_pklist (PK_LIST pk_list)
	{
	pk_list_t pkr;
	int aead;

	if (!pk_list)
	return 0;

	for (pkr = pk_list; pkr; pkr = pkr->next)
	{
	if (pkr->pk->user_id) /* selected by user ID */
	aead = pkr->pk->user_id->flags.aead;
	else
	aead = pkr->pk->flags.aead;
	if (!aead)
	return 0; /* At least one recipient does not support it. */
	}

	return default_aead_algo (); /* Yes, AEAD can be used. */
	}


	/* Print a warning for all keys in PK_LIST missing the AEAD feature
	* flag or AEAD algorithms. */
	void
	warn_missing_aead_from_pklist (PK_LIST pk_list)
	{
	PK_LIST pkr;

	for (pkr = pk_list; pkr; pkr = pkr->next)
	{
	int mdc;

	if (pkr->pk->user_id) /* selected by user ID */
	mdc = pkr->pk->user_id->flags.aead;
	else
	mdc = pkr->pk->flags.aead;
	if (!mdc)
	log_info (_("Note: key %s has no %s feature\n"),
	keystr_from_pk (pkr->pk), "AEAD");
	}
	}

	void
	warn_missing_aes_from_pklist (PK_LIST pk_list)
	{
	PK_LIST pkr;

	for (pkr = pk_list; pkr; pkr = pkr->next)
	{
	const prefitem_t *prefs;
	int i;
	int gotit = 0;

	prefs = pkr->pk->user_id? pkr->pk->user_id->prefs : pkr->pk->prefs;
	if (prefs)
	{
	for (i=0; !gotit && prefs[i].type; i++ )
	if (prefs[i].type == PREFTYPE_SYM
	&& prefs[i].value == CIPHER_ALGO_AES)
	gotit++;
	}
	if (!gotit)
	log_info (_("Note: key %s has no preference for %s\n"),
	keystr_from_pk (pkr->pk), "AES");
	}
	}

File Metadata

Mime Type: text/x-diff
Expires: Mon, Dec 23, 1:38 PM (1 d, 1 h)
Storage Engine: local-disk
Storage Format: Raw Data
Storage Handle: 9c/33/345fbc50afc0c177982e12f52df8

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions