No OneTemporary
Actions

Size

342 KB

Subscribers

None

View Options

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

	diff --git a/g10/getkey.c b/g10/getkey.c
	index cafed3a9a..3d0dd0b08 100644
	--- a/g10/getkey.c
	+++ b/g10/getkey.c
	@@ -1,4347 +1,4364 @@
	/* 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 "../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 critera. 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;
	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
	typedef struct user_id_db
	{
	struct user_id_db *next;
	keyid_list_t keyids;
	int len;
	char name[1];
	} *user_id_db_t;
	static user_id_db_t user_id_db;
	static int uid_cache_entries; /* Number of entries in uid cache. */

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



	/* Return the user ID from the given keyblock.
	* We use the primary uid flag which has been set by the merge_selfsigs
	* function. The returned value is only valid as long as the given
	* keyblock is not changed. */
	static const char *
	get_primary_uid (KBNODE keyblock, size_t * uidlen)
	{
	KBNODE k;
	const char *s;

	for (k = keyblock; k; k = k->next)
	{
	if (k->pkt->pkttype == PKT_USER_ID
	&& !k->pkt->pkt.user_id->attrib_data
	&& k->pkt->pkt.user_id->flags.primary)
	{
	*uidlen = k->pkt->pkt.user_id->len;
	return k->pkt->pkt.user_id->name;
	}
	}
	s = user_id_not_found_utf8 ();
	*uidlen = strlen (s);
	return s;
	}


	static void
	release_keyid_list (keyid_list_t k)
	{
	while (k)
	{
	keyid_list_t k2 = k->next;
	xfree (k);
	k = k2;
	}
	}

	/****************
	* Store the association of keyid and userid
	* Feed only public keys to this function.
	*/
	static void
	cache_user_id (KBNODE keyblock)
	{
	user_id_db_t r;
	const char *uid;
	size_t uidlen;
	keyid_list_t keyids = NULL;
	KBNODE k;

	for (k = keyblock; k; k = k->next)
	{
	if (k->pkt->pkttype == PKT_PUBLIC_KEY
	\|\| k->pkt->pkttype == PKT_PUBLIC_SUBKEY)
	{
	keyid_list_t a = xmalloc_clear (sizeof *a);
	/* Hmmm: For a long list of keyids it might be an advantage
	* to append the keys. */
	fingerprint_from_pk (k->pkt->pkt.public_key, a->fpr, NULL);
	keyid_from_pk (k->pkt->pkt.public_key, a->keyid);
	/* First check for duplicates. */
	for (r = user_id_db; r; r = r->next)
	{
	keyid_list_t b;

	for (b = r->keyids; b; b = b->next)
	{
	if (!memcmp (b->fpr, a->fpr, MAX_FINGERPRINT_LEN))
	{
	if (DBG_CACHE)
	log_debug ("cache_user_id: already in cache\n");
	release_keyid_list (keyids);
	xfree (a);
	return;
	}
	}
	}
	/* Now put it into the cache. */
	a->next = keyids;
	keyids = a;
	}
	}
	if (!keyids)
	BUG (); /* No key no fun. */


	uid = get_primary_uid (keyblock, &uidlen);

	if (uid_cache_entries >= MAX_UID_CACHE_ENTRIES)
	{
	/* fixme: use another algorithm to free some cache slots */
	r = user_id_db;
	user_id_db = r->next;
	release_keyid_list (r->keyids);
	xfree (r);
	uid_cache_entries--;
	}
	r = xmalloc (sizeof *r + uidlen - 1);
	r->keyids = keyids;
	r->len = uidlen;
	memcpy (r->name, uid, r->len);
	r->next = user_id_db;
	user_id_db = r;
	uid_cache_entries++;
	}


	/* 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. IF
	* FORCED_PK is not NULL, this public key is used and copied to PK. */
	gpg_error_t
	get_pubkey_for_sig (ctrl_t ctrl, PKT_public_key pk, PKT_signature sig,
	PKT_public_key *forced_pk)
	{
	const byte *fpr;
	size_t fprlen;

	if (forced_pk)
	{
	copy_public_key (pk, forced_pk);
	return 0;
	}

	/* 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;
	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
	{
	/* 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. */
	}
	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_FPR16
	&& ctx->items[n].mode != KEYDB_SEARCH_MODE_FPR20
	&& 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;
	}

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

	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);
	if (!is_mbox && *name == '<' && name[1] && name[strlen(name)-1]=='>'
	&& name[1] != '>'
	&& is_valid_mailbox_mem (name+1, strlen (name)-2))
	{
	/* The mailbox is in the form "<foo@example.org>" which is not
	* detected by is_valid_mailbox. Set the flag but keep name as
	* it is because the bracketed name is actual the better
	* specification for a local search and the other methods
	* extract the mail address anyway. */
	is_mbox = 1;
	}

	/* 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);
	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;
	int wkd_tried = 0;

	if (retctx)
	*retctx = NULL;

	is_mbox = is_valid_mailbox (name);
	if (!is_mbox && *name == '<' && name[1] && name[strlen(name)-1]=='>'
	&& name[1] != '>'
	&& is_valid_mailbox_mem (name+1, strlen (name)-2))
	{
	/* The mailbox is in the form "<foo@example.org>" which is not
	* detected by is_valid_mailbox. Set the flag but keep name as
	* it is because get_pubkey_byname does an is_valid_mailbox_mem
	* itself. */
	is_mbox = 1;
	}

	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)
	{
	goto leave;
	}

	/* 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)
	{
	release_public_key_parts (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;
	ctx = NULL;
	}

	leave:
	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_or_buffer (ctrl, fname, NULL, 0, &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;
	}


	/* Return a public key from the buffer (BUFFER, BUFLEN). The key is
	* onlyretruned if it matches the keyid given in WANT_KEYID. On
	* success the key is stored at the caller provided PKBUF structure.
	* The caller must release the content of PK by calling
	* release_public_key_parts (or, if PKBUF was malloced, using
	* free_public_key). If R_KEYBLOCK is not NULL the full keyblock is
	* also stored there. */
	gpg_error_t
	get_pubkey_from_buffer (ctrl_t ctrl, PKT_public_key *pkbuf,
	const void buffer, size_t buflen, u32 want_keyid,
	kbnode_t *r_keyblock)
	{
	gpg_error_t err;
	kbnode_t keyblock;
	kbnode_t node;
	PKT_public_key *pk;

	if (r_keyblock)
	*r_keyblock = NULL;

	err = read_key_from_file_or_buffer (ctrl, NULL, buffer, buflen, &keyblock);
	if (!err)
	{
	merge_selfsigs (ctrl, keyblock);
	for (node = keyblock; node; node = node->next)
	{
	if (node->pkt->pkttype == PKT_PUBLIC_KEY
	\|\| node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
	{
	pk = node->pkt->pkt.public_key;
	keyid_from_pk (pk, NULL);
	if (pk->keyid[0] == want_keyid[0]
	&& pk->keyid[1] == want_keyid[1])
	break;
	}
	}
	if (node)
	copy_public_key (pkbuf, pk);
	else
	err = gpg_error (GPG_ERR_NO_PUBKEY);
	}

	if (!err && r_keyblock)
	*r_keyblock = keyblock;
	else
	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 and 20-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 == 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 = fprint_len == 16 ? KEYDB_SEARCH_MODE_FPR16
	: KEYDB_SEARCH_MODE_FPR20;
	memcpy (ctx.items[0].u.fpr, fprint, 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];
	while (i < MAX_FINGERPRINT_LEN)
	fprbuf[i++] = 0;

	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);
	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 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->hashed, 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:
	* - wether 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, hash, zip;
	- size_t n, nsym, nhash, nzip;
	+ 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->hashed, 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->hashed, 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->hashed, SIGSUBPKT_PREF_SYM, &n);
	sym = p;
	nsym = p ? n : 0;
	+ p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_PREF_AEAD, &n);
	+ aead = p;
	+ naead = p ? n : 0;
	p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_PREF_HASH, &n);
	hash = p;
	nhash = p ? n : 0;
	p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_PREF_COMPR, &n);
	zip = p;
	nzip = p ? n : 0;
	if (uid->prefs)
	xfree (uid->prefs);
	n = nsym + 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->hashed, 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->hashed, 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->hashed, 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; /* Creation time of the key. */
	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. We do not support v3 keys anymore but
	* we keep the code in case a future key versions introduces a
	* hadr expire time again. */
	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++)
	memcpy (&pk->revkey[pk->numrevkeys++],
	&sig->revkey[i],
	sizeof (struct revocation_key));
	}

	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 direct key signature packet (sigclass 0x1f) 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->hashed, 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 \|\| (!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.
	* This may be a different one than from usage computation 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 \|\| (!uid->created && !uiddate)))
	{
	key_expire = uid->help_key_expire;
	uiddate = uid->created;
	}
	}
	}
	}

	/* Currently only the not anymore supported v3 keys have a maximum
	* expiration date, but future key versions may 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->hashed, 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->hashed,
	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->unhashed, 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;
	}
	}
	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 = 0;
	+ 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 PGP6 or 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 decrytion 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 --pgp6 or --pgp7 is on since pgp 6 and 7 do
	* not understand signatures made by a signing subkey. PGP 8 does. */
	req_prim = ((req_usage & PUBKEY_USAGE_CERT)
	\|\| ((PGP6 \|\| 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_user_id (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)
	{
	int rc = get_pubkey_byfprint (ctrl, pk, NULL, fpr_card, fpr_len);

	/* The key on card can be not suitable for requested usage. */
	if (rc == GPG_ERR_UNUSABLE_PUBKEY)
	fpr_card = NULL; /* Fallthrough as no card. */
	else
	return rc;
	}

	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, size_t *r_len,
	int *r_nouid)
	{
	user_id_db_t r;
	keyid_list_t a;
	int pass = 0;
	char *p;

	if (r_nouid)
	*r_nouid = 0;

	/* Try it two times; second pass reads from the database. */
	do
	{
	for (r = user_id_db; r; r = r->next)
	{
	for (a = r->keyids; a; a = a->next)
	{
	if (a->keyid[0] == keyid[0] && a->keyid[1] == keyid[1])
	{
	if (mode == 2)
	{
	/* An empty string as user id is possible. Make
	sure that the malloc allocates one byte and
	does not bail out. */
	p = xmalloc (r->len? r->len : 1);
	memcpy (p, r->name, r->len);
	if (r_len)
	*r_len = r->len;
	}
	else
	{
	if (mode)
	p = xasprintf ("%08lX%08lX %.*s",
	(ulong) keyid[0], (ulong) keyid[1],
	r->len, r->name);
	else
	p = xasprintf ("%s %.*s", keystr (keyid),
	r->len, r->name);
	if (r_len)
	*r_len = strlen (p);
	}

	return p;
	}
	}
	}
	}
	while (++pass < 2 && !get_pubkey (ctrl, NULL, keyid));

	if (mode == 2)
	p = xstrdup (user_id_not_found_utf8 ());
	else if (mode)
	p = xasprintf ("%08lX%08lX [?]", (ulong) keyid[0], (ulong) keyid[1]);
	else
	p = xasprintf ("%s [?]", keystr (keyid));

	if (r_nouid)
	*r_nouid = 1;
	if (r_len)
	*r_len = strlen (p);
	return p;
	}


	char *
	get_user_id_string_native (ctrl_t ctrl, u32 * keyid)
	{
	char *p = get_user_id_string (ctrl, keyid, 0, NULL, NULL);
	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, NULL, NULL);
	}


	/* 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)
	{
	return get_user_id_string (ctrl, keyid, 2, rn, r_nouid);
	}


	/* 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. /
	char *
	get_user_id_byfpr (ctrl_t ctrl, const byte fpr, size_t rn)
	{
	user_id_db_t r;
	char *p;
	int pass = 0;

	/* Try it two times; second pass reads from the database. */
	do
	{
	for (r = user_id_db; r; r = r->next)
	{
	keyid_list_t a;
	for (a = r->keyids; a; a = a->next)
	{
	if (!memcmp (a->fpr, fpr, MAX_FINGERPRINT_LEN))
	{
	/* An empty string as user id is possible. Make
	sure that the malloc allocates one byte and does
	not bail out. */
	p = xmalloc (r->len? r->len : 1);
	memcpy (p, r->name, r->len);
	*rn = r->len;
	return p;
	}
	}
	}
	}
	while (++pass < 2
	&& !get_pubkey_byfprint (ctrl, NULL, NULL, fpr, MAX_FINGERPRINT_LEN));
	p = xstrdup (user_id_not_found_utf8 ());
	*rn = strlen (p);
	return p;
	}

	/* 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 rn;
	char *p = get_user_id_byfpr (ctrl, fpr, &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/keyedit.c b/g10/keyedit.c
	index 7ed997ad7..a7932ce95 100644
	--- a/g10/keyedit.c
	+++ b/g10/keyedit.c
	@@ -1,6260 +1,6286 @@
	/* keyedit.c - Edit properties of a key
	* Copyright (C) 1998-2010 Free Software Foundation, Inc.
	* Copyright (C) 1998-2017 Werner Koch
	* 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 <errno.h>
	#include <ctype.h>
	#ifdef HAVE_LIBREADLINE
	# define GNUPG_LIBREADLINE_H_INCLUDED
	# include <readline/readline.h>
	#endif

	#include "gpg.h"
	#include "options.h"
	#include "packet.h"
	#include "../common/status.h"
	#include "../common/iobuf.h"
	#include "keydb.h"
	#include "photoid.h"
	#include "../common/util.h"
	#include "main.h"
	#include "trustdb.h"
	#include "filter.h"
	#include "../common/ttyio.h"
	#include "../common/status.h"
	#include "../common/i18n.h"
	#include "keyserver-internal.h"
	#include "call-agent.h"
	#include "../common/host2net.h"
	#include "tofu.h"
	#include "key-check.h"
	#include "key-clean.h"
	#include "keyedit.h"

	static void show_prefs (PKT_user_id * uid, PKT_signature * selfsig,
	int verbose);
	static void show_names (ctrl_t ctrl, estream_t fp,
	kbnode_t keyblock, PKT_public_key * pk,
	unsigned int flag, int with_prefs);
	static void show_key_with_all_names (ctrl_t ctrl, estream_t fp,
	KBNODE keyblock, int only_marked,
	int with_revoker, int with_fpr,
	int with_subkeys, int with_prefs,
	int nowarn);
	static void show_key_and_fingerprint (ctrl_t ctrl,
	kbnode_t keyblock, int with_subkeys);
	static void show_key_and_grip (kbnode_t keyblock);
	static void subkey_expire_warning (kbnode_t keyblock);
	static int menu_adduid (ctrl_t ctrl, kbnode_t keyblock,
	int photo, const char photo_name, const char uidstr);
	static void menu_deluid (KBNODE pub_keyblock);
	static int menu_delsig (ctrl_t ctrl, kbnode_t pub_keyblock);
	static int menu_clean (ctrl_t ctrl, kbnode_t keyblock, int self_only);
	static void menu_delkey (KBNODE pub_keyblock);
	static int menu_addrevoker (ctrl_t ctrl, kbnode_t pub_keyblock, int sensitive);
	static gpg_error_t menu_expire (ctrl_t ctrl, kbnode_t pub_keyblock,
	int unattended, u32 newexpiration);
	static int menu_changeusage (ctrl_t ctrl, kbnode_t keyblock);
	static int menu_backsign (ctrl_t ctrl, kbnode_t pub_keyblock);
	static int menu_set_primary_uid (ctrl_t ctrl, kbnode_t pub_keyblock);
	static int menu_set_preferences (ctrl_t ctrl, kbnode_t pub_keyblock);
	static int menu_set_keyserver_url (ctrl_t ctrl,
	const char *url, kbnode_t pub_keyblock);
	static int menu_set_notation (ctrl_t ctrl,
	const char *string, kbnode_t pub_keyblock);
	static int menu_select_uid (KBNODE keyblock, int idx);
	static int menu_select_uid_namehash (KBNODE keyblock, const char *namehash);
	static int menu_select_key (KBNODE keyblock, int idx, char *p);
	static int count_uids (KBNODE keyblock);
	static int count_uids_with_flag (KBNODE keyblock, unsigned flag);
	static int count_keys_with_flag (KBNODE keyblock, unsigned flag);
	static int count_selected_uids (KBNODE keyblock);
	static int real_uids_left (KBNODE keyblock);
	static int count_selected_keys (KBNODE keyblock);
	static int menu_revsig (ctrl_t ctrl, kbnode_t keyblock);
	static int menu_revuid (ctrl_t ctrl, kbnode_t keyblock);
	static int core_revuid (ctrl_t ctrl, kbnode_t keyblock, KBNODE node,
	const struct revocation_reason_info *reason,
	int *modified);
	static int menu_revkey (ctrl_t ctrl, kbnode_t pub_keyblock);
	static int menu_revsubkey (ctrl_t ctrl, kbnode_t pub_keyblock);
	#ifndef NO_TRUST_MODELS
	static int enable_disable_key (ctrl_t ctrl, kbnode_t keyblock, int disable);
	#endif /!NO_TRUST_MODELS/
	static void menu_showphoto (ctrl_t ctrl, kbnode_t keyblock);

	static int update_trust = 0;

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

	struct sign_attrib
	{
	int non_exportable, non_revocable;
	struct revocation_reason_info *reason;
	byte trust_depth, trust_value;
	char *trust_regexp;
	};



	/* TODO: Fix duplicated code between here and the check-sigs/list-sigs
	code in keylist.c. */
	static int
	print_and_check_one_sig_colon (ctrl_t ctrl, kbnode_t keyblock, kbnode_t node,
	int inv_sigs, int no_key, int *oth_err,
	int *is_selfsig, int print_without_key)
	{
	PKT_signature *sig = node->pkt->pkt.signature;
	int rc, sigrc;

	/* TODO: Make sure a cached sig record here still has the pk that
	issued it. See also keylist.c:list_keyblock_print */

	rc = check_key_signature (ctrl, keyblock, node, is_selfsig);
	switch (gpg_err_code (rc))
	{
	case 0:
	node->flag &= ~(NODFLG_BADSIG \| NODFLG_NOKEY \| NODFLG_SIGERR);
	sigrc = '!';
	break;
	case GPG_ERR_BAD_SIGNATURE:
	node->flag = NODFLG_BADSIG;
	sigrc = '-';
	if (inv_sigs)
	++ * inv_sigs;
	break;
	case GPG_ERR_NO_PUBKEY:
	case GPG_ERR_UNUSABLE_PUBKEY:
	node->flag = NODFLG_NOKEY;
	sigrc = '?';
	if (no_key)
	++ * no_key;
	break;
	default:
	node->flag = NODFLG_SIGERR;
	sigrc = '%';
	if (oth_err)
	++ * oth_err;
	break;
	}

	if (sigrc != '?' \|\| print_without_key)
	{
	es_printf ("sig:%c::%d:%08lX%08lX:%lu:%lu:",
	sigrc, sig->pubkey_algo, (ulong) sig->keyid[0],
	(ulong) sig->keyid[1], (ulong) sig->timestamp,
	(ulong) sig->expiredate);

	if (sig->trust_depth \|\| sig->trust_value)
	es_printf ("%d %d", sig->trust_depth, sig->trust_value);

	es_printf (":");

	if (sig->trust_regexp)
	es_write_sanitized (es_stdout,
	sig->trust_regexp, strlen (sig->trust_regexp),
	":", NULL);

	es_printf ("::%02x%c\n", sig->sig_class,
	sig->flags.exportable ? 'x' : 'l');

	if (opt.show_subpackets)
	print_subpackets_colon (sig);
	}

	return (sigrc == '!');
	}


	/*
	* Print information about a signature (rc is its status), check it
	* and return true if the signature is okay. NODE must be a signature
	* packet. With EXTENDED set all possible signature list options will
	* always be printed.
	*/
	int
	keyedit_print_one_sig (ctrl_t ctrl, estream_t fp,
	int rc, kbnode_t keyblock, kbnode_t node,
	int inv_sigs, int no_key, int *oth_err,
	int is_selfsig, int print_without_key, int extended)
	{
	PKT_signature *sig = node->pkt->pkt.signature;
	int sigrc;
	int is_rev = sig->sig_class == 0x30;

	/* TODO: Make sure a cached sig record here still has the pk that
	issued it. See also keylist.c:list_keyblock_print */

	switch (gpg_err_code (rc))
	{
	case 0:
	node->flag &= ~(NODFLG_BADSIG \| NODFLG_NOKEY \| NODFLG_SIGERR);
	sigrc = '!';
	break;
	case GPG_ERR_BAD_SIGNATURE:
	node->flag = NODFLG_BADSIG;
	sigrc = '-';
	if (inv_sigs)
	++ * inv_sigs;
	break;
	case GPG_ERR_NO_PUBKEY:
	case GPG_ERR_UNUSABLE_PUBKEY:
	node->flag = NODFLG_NOKEY;
	sigrc = '?';
	if (no_key)
	++ * no_key;
	break;
	default:
	node->flag = NODFLG_SIGERR;
	sigrc = '%';
	if (oth_err)
	++ * oth_err;
	break;
	}
	if (sigrc != '?' \|\| print_without_key)
	{
	tty_fprintf (fp, "%s%c%c %c%c%c%c%c%c %s %s",
	is_rev ? "rev" : "sig", sigrc,
	(sig->sig_class - 0x10 > 0 &&
	sig->sig_class - 0x10 <
	4) ? '0' + sig->sig_class - 0x10 : ' ',
	sig->flags.exportable ? ' ' : 'L',
	sig->flags.revocable ? ' ' : 'R',
	sig->flags.policy_url ? 'P' : ' ',
	sig->flags.notation ? 'N' : ' ',
	sig->flags.expired ? 'X' : ' ',
	(sig->trust_depth > 9) ? 'T' : (sig->trust_depth >
	0) ? '0' +
	sig->trust_depth : ' ',
	keystr (sig->keyid),
	datestr_from_sig (sig));
	if ((opt.list_options & LIST_SHOW_SIG_EXPIRE) \|\| extended )
	tty_fprintf (fp, " %s", expirestr_from_sig (sig));
	tty_fprintf (fp, " ");
	if (sigrc == '%')
	tty_fprintf (fp, "[%s] ", gpg_strerror (rc));
	else if (sigrc == '?')
	;
	else if (is_selfsig)
	{
	tty_fprintf (fp, is_rev ? _("[revocation]") : _("[self-signature]"));
	if (extended && sig->flags.chosen_selfsig)
	tty_fprintf (fp, "*");
	}
	else
	{
	size_t n;
	char *p = get_user_id (ctrl, sig->keyid, &n, NULL);
	tty_print_utf8_string2 (fp, p, n,
	opt.screen_columns - keystrlen () - 26 -
	((opt.
	list_options & LIST_SHOW_SIG_EXPIRE) ? 11
	: 0));
	xfree (p);
	}
	if (fp == log_get_stream ())
	log_printf ("\n");
	else
	tty_fprintf (fp, "\n");

	if (sig->flags.policy_url
	&& ((opt.list_options & LIST_SHOW_POLICY_URLS) \|\| extended))
	show_policy_url (sig, 3, (!fp? -1 : fp == log_get_stream ()? 1 : 0));

	if (sig->flags.notation
	&& ((opt.list_options & LIST_SHOW_NOTATIONS) \|\| extended))
	show_notation (sig, 3, (!fp? -1 : fp == log_get_stream ()? 1 : 0),
	((opt.
	list_options & LIST_SHOW_STD_NOTATIONS) ? 1 : 0) +
	((opt.
	list_options & LIST_SHOW_USER_NOTATIONS) ? 2 : 0));

	if (sig->flags.pref_ks
	&& ((opt.list_options & LIST_SHOW_KEYSERVER_URLS) \|\| extended))
	show_keyserver_url (sig, 3, (!fp? -1 : fp == log_get_stream ()? 1 : 0));

	if (extended)
	{
	PKT_public_key *pk = keyblock->pkt->pkt.public_key;
	const unsigned char *s;

	s = parse_sig_subpkt (sig->hashed, SIGSUBPKT_PRIMARY_UID, NULL);
	if (s && *s)
	tty_fprintf (fp, " [primary]\n");

	s = parse_sig_subpkt (sig->hashed, SIGSUBPKT_KEY_EXPIRE, NULL);
	if (s && buf32_to_u32 (s))
	tty_fprintf (fp, " [expires: %s]\n",
	isotimestamp (pk->timestamp + buf32_to_u32 (s)));
	}
	}

	return (sigrc == '!');
	}


	static int
	print_and_check_one_sig (ctrl_t ctrl, kbnode_t keyblock, kbnode_t node,
	int inv_sigs, int no_key, int *oth_err,
	int *is_selfsig, int print_without_key, int extended)
	{
	int rc;

	rc = check_key_signature (ctrl, keyblock, node, is_selfsig);
	return keyedit_print_one_sig (ctrl, NULL, rc,
	keyblock, node, inv_sigs, no_key, oth_err,
	*is_selfsig, print_without_key, extended);
	}


	static int
	sign_mk_attrib (PKT_signature * sig, void *opaque)
	{
	struct sign_attrib *attrib = opaque;
	byte buf[8];

	if (attrib->non_exportable)
	{
	buf[0] = 0; /* not exportable */
	build_sig_subpkt (sig, SIGSUBPKT_EXPORTABLE, buf, 1);
	}

	if (attrib->non_revocable)
	{
	buf[0] = 0; /* not revocable */
	build_sig_subpkt (sig, SIGSUBPKT_REVOCABLE, buf, 1);
	}

	if (attrib->reason)
	revocation_reason_build_cb (sig, attrib->reason);

	if (attrib->trust_depth)
	{
	/* Not critical. If someone doesn't understand trust sigs,
	this can still be a valid regular signature. */
	buf[0] = attrib->trust_depth;
	buf[1] = attrib->trust_value;
	build_sig_subpkt (sig, SIGSUBPKT_TRUST, buf, 2);

	/* Critical. If someone doesn't understands regexps, this
	whole sig should be invalid. Note the +1 for the length -
	regexps are null terminated. */
	if (attrib->trust_regexp)
	build_sig_subpkt (sig, SIGSUBPKT_FLAG_CRITICAL \| SIGSUBPKT_REGEXP,
	attrib->trust_regexp,
	strlen (attrib->trust_regexp) + 1);
	}

	return 0;
	}


	static void
	trustsig_prompt (byte * trust_value, byte * trust_depth, char **regexp)
	{
	char *p;

	*trust_value = 0;
	*trust_depth = 0;
	*regexp = NULL;

	/* Same string as pkclist.c:do_edit_ownertrust */
	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");
	tty_printf (_(" %d = I trust marginally\n"), 1);
	tty_printf (_(" %d = I trust fully\n"), 2);
	tty_printf ("\n");

	while (*trust_value == 0)
	{
	p = cpr_get ("trustsig_prompt.trust_value", _("Your selection? "));
	trim_spaces (p);
	cpr_kill_prompt ();
	/* 60 and 120 are as per RFC2440 */
	if (p[0] == '1' && !p[1])
	*trust_value = 60;
	else if (p[0] == '2' && !p[1])
	*trust_value = 120;
	xfree (p);
	}

	tty_printf ("\n");

	tty_printf (_("Please enter the depth of this trust signature.\n"
	"A depth greater than 1 allows the key you are"
	" signing to make\n"
	"trust signatures on your behalf.\n"));
	tty_printf ("\n");

	while (*trust_depth == 0)
	{
	p = cpr_get ("trustsig_prompt.trust_depth", _("Your selection? "));
	trim_spaces (p);
	cpr_kill_prompt ();
	*trust_depth = atoi (p);
	xfree (p);
	}

	tty_printf ("\n");

	tty_printf (_("Please enter a domain to restrict this signature, "
	"or enter for none.\n"));

	tty_printf ("\n");

	p = cpr_get ("trustsig_prompt.trust_regexp", _("Your selection? "));
	trim_spaces (p);
	cpr_kill_prompt ();

	if (strlen (p) > 0)
	{
	char *q = p;
	int regexplen = 100, ind;

	*regexp = xmalloc (regexplen);

	/* Now mangle the domain the user entered into a regexp. To do
	this, \-escape everything that isn't alphanumeric, and attach
	"<[^>]+[@.]" to the front, and ">$" to the end. */

	strcpy (*regexp, "<[^>]+[@.]");
	ind = strlen (*regexp);

	while (*q)
	{
	if (!((q >= 'A' && q <= 'Z')
	\|\| (q >= 'a' && q <= 'z') \|\| (q >= '0' && q <= '9')))
	(*regexp)[ind++] = '\\';

	(regexp)[ind++] = q;

	if ((regexplen - ind) < 3)
	{
	regexplen += 100;
	regexp = xrealloc (regexp, regexplen);
	}

	q++;
	}

	(*regexp)[ind] = '\0';
	strcat (*regexp, ">$");
	}

	xfree (p);
	tty_printf ("\n");
	}


	/*
	* Loop over all LOCUSR and sign the uids after asking. If no
	* user id is marked, all user ids will be signed; if some user_ids
	* are marked only those will be signed. If QUICK is true the
	* function won't ask the user and use sensible defaults.
	*/
	static int
	sign_uids (ctrl_t ctrl, estream_t fp,
	kbnode_t keyblock, strlist_t locusr, int *ret_modified,
	int local, int nonrevocable, int trust, int interactive,
	int quick)
	{
	int rc = 0;
	SK_LIST sk_list = NULL;
	SK_LIST sk_rover = NULL;
	PKT_public_key *pk = NULL;
	KBNODE node, uidnode;
	PKT_public_key *primary_pk = NULL;
	int select_all = !count_selected_uids (keyblock) \|\| interactive;

	/* Build a list of all signators.
	*
	* We use the CERT flag to request the primary which must always
	* be one which is capable of signing keys. I can't see a reason
	* why to sign keys using a subkey. Implementation of USAGE_CERT
	* is just a hack in getkey.c and does not mean that a subkey
	* marked as certification capable will be used. */
	rc = build_sk_list (ctrl, locusr, &sk_list, PUBKEY_USAGE_CERT);
	if (rc)
	goto leave;

	/* Loop over all signators. */
	for (sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next)
	{
	u32 sk_keyid[2], pk_keyid[2];
	char p, trust_regexp = NULL;
	int class = 0, selfsig = 0;
	u32 duration = 0, timestamp = 0;
	byte trust_depth = 0, trust_value = 0;

	pk = sk_rover->pk;
	keyid_from_pk (pk, sk_keyid);

	/* Set mark A for all selected user ids. */
	for (node = keyblock; node; node = node->next)
	{
	if (select_all \|\| (node->flag & NODFLG_SELUID))
	node->flag \|= NODFLG_MARK_A;
	else
	node->flag &= ~NODFLG_MARK_A;
	}

	/* Reset mark for uids which are already signed. */
	uidnode = NULL;
	for (node = keyblock; node; node = node->next)
	{
	if (node->pkt->pkttype == PKT_PUBLIC_KEY)
	{
	primary_pk = node->pkt->pkt.public_key;
	keyid_from_pk (primary_pk, pk_keyid);

	/* Is this a self-sig? */
	if (pk_keyid[0] == sk_keyid[0] && pk_keyid[1] == sk_keyid[1])
	selfsig = 1;
	}
	else if (node->pkt->pkttype == PKT_USER_ID)
	{
	uidnode = (node->flag & NODFLG_MARK_A) ? node : NULL;
	if (uidnode)
	{
	int yesreally = 0;
	char *user;

	user = utf8_to_native (uidnode->pkt->pkt.user_id->name,
	uidnode->pkt->pkt.user_id->len, 0);

	if (opt.only_sign_text_ids
	&& uidnode->pkt->pkt.user_id->attribs)
	{
	tty_fprintf (fp, _("Skipping user ID \"%s\","
	" which is not a text ID.\n"),
	user);
	uidnode->flag &= ~NODFLG_MARK_A;
	uidnode = NULL;
	}
	else if (uidnode->pkt->pkt.user_id->flags.revoked)
	{
	tty_fprintf (fp, _("User ID \"%s\" is revoked."), user);

	if (selfsig)
	tty_fprintf (fp, "\n");
	else if (opt.expert && !quick)
	{
	tty_fprintf (fp, "\n");
	/* No, so remove the mark and continue */
	if (!cpr_get_answer_is_yes ("sign_uid.revoke_okay",
	_("Are you sure you "
	"still want to sign "
	"it? (y/N) ")))
	{
	uidnode->flag &= ~NODFLG_MARK_A;
	uidnode = NULL;
	}
	else if (interactive)
	yesreally = 1;
	}
	else
	{
	uidnode->flag &= ~NODFLG_MARK_A;
	uidnode = NULL;
	tty_fprintf (fp, _(" Unable to sign.\n"));
	}
	}
	else if (uidnode->pkt->pkt.user_id->flags.expired)
	{
	tty_fprintf (fp, _("User ID \"%s\" is expired."), user);

	if (selfsig)
	tty_fprintf (fp, "\n");
	else if (opt.expert && !quick)
	{
	tty_fprintf (fp, "\n");
	/* No, so remove the mark and continue */
	if (!cpr_get_answer_is_yes ("sign_uid.expire_okay",
	_("Are you sure you "
	"still want to sign "
	"it? (y/N) ")))
	{
	uidnode->flag &= ~NODFLG_MARK_A;
	uidnode = NULL;
	}
	else if (interactive)
	yesreally = 1;
	}
	else
	{
	uidnode->flag &= ~NODFLG_MARK_A;
	uidnode = NULL;
	tty_fprintf (fp, _(" Unable to sign.\n"));
	}
	}
	else if (!uidnode->pkt->pkt.user_id->created && !selfsig)
	{
	tty_fprintf (fp, _("User ID \"%s\" is not self-signed."),
	user);

	if (opt.expert && !quick)
	{
	tty_fprintf (fp, "\n");
	/* No, so remove the mark and continue */
	if (!cpr_get_answer_is_yes ("sign_uid.nosig_okay",
	_("Are you sure you "
	"still want to sign "
	"it? (y/N) ")))
	{
	uidnode->flag &= ~NODFLG_MARK_A;
	uidnode = NULL;
	}
	else if (interactive)
	yesreally = 1;
	}
	else
	{
	uidnode->flag &= ~NODFLG_MARK_A;
	uidnode = NULL;
	tty_fprintf (fp, _(" Unable to sign.\n"));
	}
	}

	if (uidnode && interactive && !yesreally && !quick)
	{
	tty_fprintf (fp,
	_("User ID \"%s\" is signable. "), user);
	if (!cpr_get_answer_is_yes ("sign_uid.sign_okay",
	_("Sign it? (y/N) ")))
	{
	uidnode->flag &= ~NODFLG_MARK_A;
	uidnode = NULL;
	}
	}

	xfree (user);
	}
	}
	else if (uidnode && node->pkt->pkttype == PKT_SIGNATURE
	&& (node->pkt->pkt.signature->sig_class & ~3) == 0x10)
	{
	if (sk_keyid[0] == node->pkt->pkt.signature->keyid[0]
	&& sk_keyid[1] == node->pkt->pkt.signature->keyid[1])
	{
	char buf[50];
	char *user;

	user = utf8_to_native (uidnode->pkt->pkt.user_id->name,
	uidnode->pkt->pkt.user_id->len, 0);

	/* It's a v3 self-sig. Make it into a v4 self-sig? */
	if (node->pkt->pkt.signature->version < 4
	&& selfsig && !quick)
	{
	tty_fprintf (fp,
	_("The self-signature on \"%s\"\n"
	"is a PGP 2.x-style signature.\n"), user);

	/* Note that the regular PGP2 warning below
	still applies if there are no v4 sigs on
	this key at all. */

	if (opt.expert)
	if (cpr_get_answer_is_yes ("sign_uid.v4_promote_okay",
	_("Do you want to promote "
	"it to an OpenPGP self-"
	"signature? (y/N) ")))
	{
	node->flag \|= NODFLG_DELSIG;
	xfree (user);
	continue;
	}
	}

	/* Is the current signature expired? */
	if (node->pkt->pkt.signature->flags.expired)
	{
	tty_fprintf (fp, _("Your current signature on \"%s\"\n"
	"has expired.\n"), user);

	if (quick \|\| cpr_get_answer_is_yes
	("sign_uid.replace_expired_okay",
	_("Do you want to issue a "
	"new signature to replace "
	"the expired one? (y/N) ")))
	{
	/* Mark these for later deletion. We
	don't want to delete them here, just in
	case the replacement signature doesn't
	happen for some reason. We only delete
	these after the replacement is already
	in place. */

	node->flag \|= NODFLG_DELSIG;
	xfree (user);
	continue;
	}
	}

	if (!node->pkt->pkt.signature->flags.exportable && !local)
	{
	/* It's a local sig, and we want to make a
	exportable sig. */
	tty_fprintf (fp, _("Your current signature on \"%s\"\n"
	"is a local signature.\n"), user);

	if (quick \|\| cpr_get_answer_is_yes
	("sign_uid.local_promote_okay",
	_("Do you want to promote "
	"it to a full exportable " "signature? (y/N) ")))
	{
	/* Mark these for later deletion. We
	don't want to delete them here, just in
	case the replacement signature doesn't
	happen for some reason. We only delete
	these after the replacement is already
	in place. */

	node->flag \|= NODFLG_DELSIG;
	xfree (user);
	continue;
	}
	}

	/* Fixme: see whether there is a revocation in which
	* case we should allow signing it again. */
	if (!node->pkt->pkt.signature->flags.exportable && local)
	tty_fprintf ( fp,
	_("\"%s\" was already locally signed by key %s\n"),
	user, keystr_from_pk (pk));
	else
	tty_fprintf (fp,
	_("\"%s\" was already signed by key %s\n"),
	user, keystr_from_pk (pk));

	if (opt.expert && !quick
	&& cpr_get_answer_is_yes ("sign_uid.dupe_okay",
	_("Do you want to sign it "
	"again anyway? (y/N) ")))
	{
	/* Don't delete the old sig here since this is
	an --expert thing. */
	xfree (user);
	continue;
	}

	snprintf (buf, sizeof buf, "%08lX%08lX",
	(ulong) pk->keyid[0], (ulong) pk->keyid[1]);
	write_status_text (STATUS_ALREADY_SIGNED, buf);
	uidnode->flag &= ~NODFLG_MARK_A; /* remove mark */

	xfree (user);
	}
	}
	}

	/* Check whether any uids are left for signing. */
	if (!count_uids_with_flag (keyblock, NODFLG_MARK_A))
	{
	tty_fprintf (fp, _("Nothing to sign with key %s\n"),
	keystr_from_pk (pk));
	continue;
	}

	/* Ask whether we really should sign these user id(s). */
	tty_fprintf (fp, "\n");
	show_key_with_all_names (ctrl, fp, keyblock, 1, 0, 1, 0, 0, 0);
	tty_fprintf (fp, "\n");

	if (primary_pk->expiredate && !selfsig)
	{
	/* Static analyzer note: A claim that PRIMARY_PK might be
	NULL is not correct because it set from the public key
	packet which is always the first packet in a keyblock and
	parsed in the above loop over the keyblock. In case the
	keyblock has no packets at all and thus the loop was not
	entered the above count_uids_with_flag would have
	detected this case. */

	u32 now = make_timestamp ();

	if (primary_pk->expiredate <= now)
	{
	tty_fprintf (fp, _("This key has expired!"));

	if (opt.expert && !quick)
	{
	tty_fprintf (fp, " ");
	if (!cpr_get_answer_is_yes ("sign_uid.expired_okay",
	_("Are you sure you still "
	"want to sign it? (y/N) ")))
	continue;
	}
	else
	{
	tty_fprintf (fp, _(" Unable to sign.\n"));
	continue;
	}
	}
	else
	{
	tty_fprintf (fp, _("This key is due to expire on %s.\n"),
	expirestr_from_pk (primary_pk));

	if (opt.ask_cert_expire && !quick)
	{
	char *answer = cpr_get ("sign_uid.expire",
	_("Do you want your signature to "
	"expire at the same time? (Y/n) "));
	if (answer_is_yes_no_default (answer, 1))
	{
	/* This fixes the signature timestamp we're
	going to make as now. This is so the
	expiration date is exactly correct, and not
	a few seconds off (due to the time it takes
	to answer the questions, enter the
	passphrase, etc). */
	timestamp = now;
	duration = primary_pk->expiredate - now;
	}

	cpr_kill_prompt ();
	xfree (answer);
	}
	}
	}

	/* Only ask for duration if we haven't already set it to match
	the expiration of the pk */
	if (!duration && !selfsig)
	{
	if (opt.ask_cert_expire && !quick)
	duration = ask_expire_interval (1, opt.def_cert_expire);
	else
	duration = parse_expire_string (opt.def_cert_expire);
	}

	if (selfsig)
	;
	else
	{
	if (opt.batch \|\| !opt.ask_cert_level \|\| quick)
	class = 0x10 + opt.def_cert_level;
	else
	{
	char *answer;

	tty_fprintf (fp,
	_("How carefully have you verified the key you are "
	"about to sign actually belongs\nto the person "
	"named above? If you don't know what to "
	"answer, enter \"0\".\n"));
	tty_fprintf (fp, "\n");
	tty_fprintf (fp, _(" (0) I will not answer.%s\n"),
	opt.def_cert_level == 0 ? " (default)" : "");
	tty_fprintf (fp, _(" (1) I have not checked at all.%s\n"),
	opt.def_cert_level == 1 ? " (default)" : "");
	tty_fprintf (fp, _(" (2) I have done casual checking.%s\n"),
	opt.def_cert_level == 2 ? " (default)" : "");
	tty_fprintf (fp,
	_(" (3) I have done very careful checking.%s\n"),
	opt.def_cert_level == 3 ? " (default)" : "");
	tty_fprintf (fp, "\n");

	while (class == 0)
	{
	answer = cpr_get ("sign_uid.class",
	_("Your selection? "
	"(enter '?' for more information): "));
	if (answer[0] == '\0')
	class = 0x10 + opt.def_cert_level; /* Default */
	else if (ascii_strcasecmp (answer, "0") == 0)
	class = 0x10; /* Generic */
	else if (ascii_strcasecmp (answer, "1") == 0)
	class = 0x11; /* Persona */
	else if (ascii_strcasecmp (answer, "2") == 0)
	class = 0x12; /* Casual */
	else if (ascii_strcasecmp (answer, "3") == 0)
	class = 0x13; /* Positive */
	else
	tty_fprintf (fp, _("Invalid selection.\n"));

	xfree (answer);
	}
	}

	if (trust && !quick)
	trustsig_prompt (&trust_value, &trust_depth, &trust_regexp);
	}

	if (!quick)
	{
	p = get_user_id_native (ctrl, sk_keyid);
	tty_fprintf (fp,
	_("Are you sure that you want to sign this key with your\n"
	"key \"%s\" (%s)\n"), p, keystr_from_pk (pk));
	xfree (p);
	}

	if (selfsig)
	{
	tty_fprintf (fp, "\n");
	tty_fprintf (fp, _("This will be a self-signature.\n"));

	if (local)
	{
	tty_fprintf (fp, "\n");
	tty_fprintf (fp, _("WARNING: the signature will not be marked "
	"as non-exportable.\n"));
	}

	if (nonrevocable)
	{
	tty_fprintf (fp, "\n");
	tty_fprintf (fp, _("WARNING: the signature will not be marked "
	"as non-revocable.\n"));
	}
	}
	else
	{
	if (local)
	{
	tty_fprintf (fp, "\n");
	tty_fprintf (fp,
	_("The signature will be marked as non-exportable.\n"));
	}

	if (nonrevocable)
	{
	tty_fprintf (fp, "\n");
	tty_fprintf (fp,
	_("The signature will be marked as non-revocable.\n"));
	}

	switch (class)
	{
	case 0x11:
	tty_fprintf (fp, "\n");
	tty_fprintf (fp, _("I have not checked this key at all.\n"));
	break;

	case 0x12:
	tty_fprintf (fp, "\n");
	tty_fprintf (fp, _("I have checked this key casually.\n"));
	break;

	case 0x13:
	tty_fprintf (fp, "\n");
	tty_fprintf (fp, _("I have checked this key very carefully.\n"));
	break;
	}
	}

	tty_fprintf (fp, "\n");

	if (opt.batch && opt.answer_yes)
	;
	else if (quick)
	;
	else if (!cpr_get_answer_is_yes ("sign_uid.okay",
	_("Really sign? (y/N) ")))
	continue;

	/* Now we can sign the user ids. */
	reloop: /* (Must use this, because we are modifying the list.) */
	primary_pk = NULL;
	for (node = keyblock; node; node = node->next)
	{
	if (node->pkt->pkttype == PKT_PUBLIC_KEY)
	primary_pk = node->pkt->pkt.public_key;
	else if (node->pkt->pkttype == PKT_USER_ID
	&& (node->flag & NODFLG_MARK_A))
	{
	PACKET *pkt;
	PKT_signature *sig;
	struct sign_attrib attrib;

	log_assert (primary_pk);
	memset (&attrib, 0, sizeof attrib);
	attrib.non_exportable = local;
	attrib.non_revocable = nonrevocable;
	attrib.trust_depth = trust_depth;
	attrib.trust_value = trust_value;
	attrib.trust_regexp = trust_regexp;
	node->flag &= ~NODFLG_MARK_A;

	/* We force creation of a v4 signature for local
	* signatures, otherwise we would not generate the
	* subpacket with v3 keys and the signature becomes
	* exportable. */

	if (selfsig)
	rc = make_keysig_packet (ctrl, &sig, primary_pk,
	node->pkt->pkt.user_id,
	NULL,
	pk,
	0x13, 0, 0, 0,
	keygen_add_std_prefs, primary_pk,
	NULL);
	else
	rc = make_keysig_packet (ctrl, &sig, primary_pk,
	node->pkt->pkt.user_id,
	NULL,
	pk,
	class, 0,
	timestamp, duration,
	sign_mk_attrib, &attrib,
	NULL);
	if (rc)
	{
	write_status_error ("keysig", rc);
	log_error (_("signing failed: %s\n"), gpg_strerror (rc));
	goto leave;
	}

	ret_modified = 1; / We changed the keyblock. */
	update_trust = 1;

	pkt = xmalloc_clear (sizeof *pkt);
	pkt->pkttype = PKT_SIGNATURE;
	pkt->pkt.signature = sig;
	insert_kbnode (node, new_kbnode (pkt), PKT_SIGNATURE);
	goto reloop;
	}
	}

	/* Delete any sigs that got promoted */
	for (node = keyblock; node; node = node->next)
	if (node->flag & NODFLG_DELSIG)
	delete_kbnode (node);
	} /* End loop over signators. */

	leave:
	release_sk_list (sk_list);
	return rc;
	}


	/*
	* Change the passphrase of the primary and all secondary keys. Note
	* that it is common to use only one passphrase for the primary and
	* all subkeys. However, this is now (since GnuPG 2.1) all up to the
	* gpg-agent. Returns 0 on success or an error code.
	*/
	static gpg_error_t
	change_passphrase (ctrl_t ctrl, kbnode_t keyblock)
	{
	gpg_error_t err;
	kbnode_t node;
	PKT_public_key *pk;
	int any;
	u32 keyid[2], subid[2];
	char *hexgrip = NULL;
	char *cache_nonce = NULL;
	char *passwd_nonce = NULL;

	node = find_kbnode (keyblock, PKT_PUBLIC_KEY);
	if (!node)
	{
	log_error ("Oops; public key missing!\n");
	err = gpg_error (GPG_ERR_INTERNAL);
	goto leave;
	}
	pk = node->pkt->pkt.public_key;
	keyid_from_pk (pk, keyid);

	/* Check whether it is likely that we will be able to change the
	passphrase for any subkey. */
	for (any = 0, node = keyblock; node; node = node->next)
	{
	if (node->pkt->pkttype == PKT_PUBLIC_KEY
	\|\| node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
	{
	char *serialno;

	pk = node->pkt->pkt.public_key;
	keyid_from_pk (pk, subid);

	xfree (hexgrip);
	err = hexkeygrip_from_pk (pk, &hexgrip);
	if (err)
	goto leave;
	err = agent_get_keyinfo (ctrl, hexgrip, &serialno, NULL);
	if (!err && serialno)
	; /* Key on card. */
	else if (gpg_err_code (err) == GPG_ERR_NOT_FOUND)
	; /* Maybe stub key. */
	else if (!err)
	any = 1; /* Key is known. */
	else
	log_error ("key %s: error getting keyinfo from agent: %s\n",
	keystr_with_sub (keyid, subid), gpg_strerror (err));
	xfree (serialno);
	}
	}
	err = 0;
	if (!any)
	{
	tty_printf (_("Key has only stub or on-card key items - "
	"no passphrase to change.\n"));
	goto leave;
	}

	/* Change the passphrase for all keys. */
	for (node = keyblock; node; node = node->next)
	{
	if (node->pkt->pkttype == PKT_PUBLIC_KEY
	\|\| node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
	{
	char *desc;

	pk = node->pkt->pkt.public_key;
	keyid_from_pk (pk, subid);

	xfree (hexgrip);
	err = hexkeygrip_from_pk (pk, &hexgrip);
	if (err)
	goto leave;

	/* Note that when using --dry-run we don't change the
	* passphrase but merely verify the current passphrase. */
	desc = gpg_format_keydesc (ctrl, pk, FORMAT_KEYDESC_NORMAL, 1);
	err = agent_passwd (ctrl, hexgrip, desc, !!opt.dry_run,
	&cache_nonce, &passwd_nonce);
	xfree (desc);

	if (err)
	log_log ((gpg_err_code (err) == GPG_ERR_CANCELED
	\|\| gpg_err_code (err) == GPG_ERR_FULLY_CANCELED)
	? GPGRT_LOG_INFO : GPGRT_LOG_ERROR,
	_("key %s: error changing passphrase: %s\n"),
	keystr_with_sub (keyid, subid),
	gpg_strerror (err));
	if (gpg_err_code (err) == GPG_ERR_FULLY_CANCELED)
	break;
	}
	}

	leave:
	xfree (hexgrip);
	xfree (cache_nonce);
	xfree (passwd_nonce);
	return err;
	}



	/* Fix various problems in the keyblock. Returns true if the keyblock
	was changed. Note that a pointer to the keyblock must be given and
	the function may change it (i.e. replacing the first node). */
	static int
	fix_keyblock (ctrl_t ctrl, kbnode_t *keyblockp)
	{
	int changed = 0;

	if (collapse_uids (keyblockp))
	changed++;
	if (key_check_all_keysigs (ctrl, 1, *keyblockp, 0, 1))
	changed++;
	reorder_keyblock (*keyblockp);
	/* If we modified the keyblock, make sure the flags are right. */
	if (changed)
	merge_keys_and_selfsig (ctrl, *keyblockp);

	return changed;
	}


	static int
	parse_sign_type (const char str, int localsig, int *nonrevokesig,
	int *trustsig)
	{
	const char *p = str;

	while (*p)
	{
	if (ascii_strncasecmp (p, "l", 1) == 0)
	{
	*localsig = 1;
	p++;
	}
	else if (ascii_strncasecmp (p, "nr", 2) == 0)
	{
	*nonrevokesig = 1;
	p += 2;
	}
	else if (ascii_strncasecmp (p, "t", 1) == 0)
	{
	*trustsig = 1;
	p++;
	}
	else
	return 0;
	}

	return 1;
	}



	/*
	* Menu driven key editor. If seckey_check is true, then a secret key
	* that matches username will be looked for. If it is false, not all
	* commands will be available.
	*
	* Note: to keep track of certain selections we use node->mark MARKBIT_xxxx.
	*/

	/* Need an SK for this command */
	#define KEYEDIT_NEED_SK 1
	/* Need an SUB KEY for this command */
	#define KEYEDIT_NEED_SUBSK 2
	/* Match the tail of the string */
	#define KEYEDIT_TAIL_MATCH 8

	enum cmdids
	{
	cmdNONE = 0,
	cmdQUIT, cmdHELP, cmdFPR, cmdLIST, cmdSELUID, cmdCHECK, cmdSIGN,
	cmdREVSIG, cmdREVKEY, cmdREVUID, cmdDELSIG, cmdPRIMARY, cmdDEBUG,
	cmdSAVE, cmdADDUID, cmdADDPHOTO, cmdDELUID, cmdADDKEY, cmdDELKEY,
	cmdADDREVOKER, cmdTOGGLE, cmdSELKEY, cmdPASSWD, cmdTRUST, cmdPREF,
	cmdEXPIRE, cmdCHANGEUSAGE, cmdBACKSIGN,
	#ifndef NO_TRUST_MODELS
	cmdENABLEKEY, cmdDISABLEKEY,
	#endif /!NO_TRUST_MODELS/
	cmdSHOWPREF,
	cmdSETPREF, cmdPREFKS, cmdNOTATION, cmdINVCMD, cmdSHOWPHOTO, cmdUPDTRUST,
	cmdCHKTRUST, cmdADDCARDKEY, cmdKEYTOCARD, cmdBKUPTOCARD,
	cmdCLEAN, cmdMINIMIZE, cmdGRIP, cmdNOP
	};

	static struct
	{
	const char *name;
	enum cmdids id;
	int flags;
	const char *desc;
	} cmds[] =
	{
	{ "quit", cmdQUIT, 0, N_("quit this menu")},
	{ "q", cmdQUIT, 0, NULL},
	{ "save", cmdSAVE, 0, N_("save and quit")},
	{ "help", cmdHELP, 0, N_("show this help")},
	{ "?", cmdHELP, 0, NULL},
	{ "fpr", cmdFPR, 0, N_("show key fingerprint")},
	{ "grip", cmdGRIP, 0, N_("show the keygrip")},
	{ "list", cmdLIST, 0, N_("list key and user IDs")},
	{ "l", cmdLIST, 0, NULL},
	{ "uid", cmdSELUID, 0, N_("select user ID N")},
	{ "key", cmdSELKEY, 0, N_("select subkey N")},
	{ "check", cmdCHECK, 0, N_("check signatures")},
	{ "c", cmdCHECK, 0, NULL},
	{ "change-usage", cmdCHANGEUSAGE, KEYEDIT_NEED_SK, NULL},
	{ "cross-certify", cmdBACKSIGN, KEYEDIT_NEED_SK, NULL},
	{ "backsign", cmdBACKSIGN, KEYEDIT_NEED_SK, NULL},
	{ "sign", cmdSIGN, KEYEDIT_TAIL_MATCH,
	N_("sign selected user IDs [* see below for related commands]")},
	{ "s", cmdSIGN, 0, NULL},
	/* "lsign" and friends will never match since "sign" comes first
	and it is a tail match. They are just here so they show up in
	the help menu. */
	{ "lsign", cmdNOP, 0, N_("sign selected user IDs locally")},
	{ "tsign", cmdNOP, 0, N_("sign selected user IDs with a trust signature")},
	{ "nrsign", cmdNOP, 0,
	N_("sign selected user IDs with a non-revocable signature")},
	{ "debug", cmdDEBUG, 0, NULL},
	{ "adduid", cmdADDUID, KEYEDIT_NEED_SK, N_("add a user ID")},
	{ "addphoto", cmdADDPHOTO, KEYEDIT_NEED_SK,
	N_("add a photo ID")},
	{ "deluid", cmdDELUID, 0, N_("delete selected user IDs")},
	/* delphoto is really deluid in disguise */
	{ "delphoto", cmdDELUID, 0, NULL},
	{ "addkey", cmdADDKEY, KEYEDIT_NEED_SK, N_("add a subkey")},
	#ifdef ENABLE_CARD_SUPPORT
	{ "addcardkey", cmdADDCARDKEY, KEYEDIT_NEED_SK,
	N_("add a key to a smartcard")},
	{ "keytocard", cmdKEYTOCARD, KEYEDIT_NEED_SK \| KEYEDIT_NEED_SUBSK,
	N_("move a key to a smartcard")},
	{ "bkuptocard", cmdBKUPTOCARD, KEYEDIT_NEED_SK \| KEYEDIT_NEED_SUBSK,
	N_("move a backup key to a smartcard")},
	#endif /ENABLE_CARD_SUPPORT /
	{ "delkey", cmdDELKEY, 0, N_("delete selected subkeys")},
	{ "addrevoker", cmdADDREVOKER, KEYEDIT_NEED_SK,
	N_("add a revocation key")},
	{ "delsig", cmdDELSIG, 0,
	N_("delete signatures from the selected user IDs")},
	{ "expire", cmdEXPIRE, KEYEDIT_NEED_SK \| KEYEDIT_NEED_SUBSK,
	N_("change the expiration date for the key or selected subkeys")},
	{ "primary", cmdPRIMARY, KEYEDIT_NEED_SK,
	N_("flag the selected user ID as primary")},
	{ "toggle", cmdTOGGLE, KEYEDIT_NEED_SK, NULL}, /* Dummy command. */
	{ "t", cmdTOGGLE, KEYEDIT_NEED_SK, NULL},
	{ "pref", cmdPREF, 0, N_("list preferences (expert)")},
	{ "showpref", cmdSHOWPREF, 0, N_("list preferences (verbose)")},
	{ "setpref", cmdSETPREF, KEYEDIT_NEED_SK,
	N_("set preference list for the selected user IDs")},
	{ "updpref", cmdSETPREF, KEYEDIT_NEED_SK, NULL},
	{ "keyserver", cmdPREFKS, KEYEDIT_NEED_SK,
	N_("set the preferred keyserver URL for the selected user IDs")},
	{ "notation", cmdNOTATION, KEYEDIT_NEED_SK,
	N_("set a notation for the selected user IDs")},
	{ "passwd", cmdPASSWD, KEYEDIT_NEED_SK \| KEYEDIT_NEED_SUBSK,
	N_("change the passphrase")},
	{ "password", cmdPASSWD, KEYEDIT_NEED_SK \| KEYEDIT_NEED_SUBSK, NULL},
	#ifndef NO_TRUST_MODELS
	{ "trust", cmdTRUST, 0, N_("change the ownertrust")},
	#endif /!NO_TRUST_MODELS/
	{ "revsig", cmdREVSIG, 0,
	N_("revoke signatures on the selected user IDs")},
	{ "revuid", cmdREVUID, KEYEDIT_NEED_SK,
	N_("revoke selected user IDs")},
	{ "revphoto", cmdREVUID, KEYEDIT_NEED_SK, NULL},
	{ "revkey", cmdREVKEY, KEYEDIT_NEED_SK,
	N_("revoke key or selected subkeys")},
	#ifndef NO_TRUST_MODELS
	{ "enable", cmdENABLEKEY, 0, N_("enable key")},
	{ "disable", cmdDISABLEKEY, 0, N_("disable key")},
	#endif /!NO_TRUST_MODELS/
	{ "showphoto", cmdSHOWPHOTO, 0, N_("show selected photo IDs")},
	{ "clean", cmdCLEAN, 0,
	N_("compact unusable user IDs and remove unusable signatures from key")},
	{ "minimize", cmdMINIMIZE, 0,
	N_("compact unusable user IDs and remove all signatures from key")},

	{ NULL, cmdNONE, 0, NULL}
	};



	#ifdef HAVE_LIBREADLINE

	/*
	These two functions are used by readline for command completion.
	*/

	static char *
	command_generator (const char *text, int state)
	{
	static int list_index, len;
	const char *name;

	/* If this is a new word to complete, initialize now. This includes
	saving the length of TEXT for efficiency, and initializing the
	index variable to 0. */
	if (!state)
	{
	list_index = 0;
	len = strlen (text);
	}

	/* Return the next partial match */
	while ((name = cmds[list_index].name))
	{
	/* Only complete commands that have help text */
	if (cmds[list_index++].desc && strncmp (name, text, len) == 0)
	return strdup (name);
	}

	return NULL;
	}

	static char **
	keyedit_completion (const char *text, int start, int end)
	{
	/* If we are at the start of a line, we try and command-complete.
	If not, just do nothing for now. */

	(void) end;

	if (start == 0)
	return rl_completion_matches (text, command_generator);

	rl_attempted_completion_over = 1;

	return NULL;
	}
	#endif /* HAVE_LIBREADLINE */



	/* Main function of the menu driven key editor. */
	void
	keyedit_menu (ctrl_t ctrl, const char *username, strlist_t locusr,
	strlist_t commands, int quiet, int seckey_check)
	{
	enum cmdids cmd = 0;
	gpg_error_t err = 0;
	KBNODE keyblock = NULL;
	KEYDB_HANDLE kdbhd = NULL;
	int have_seckey = 0;
	int have_anyseckey = 0;
	char *answer = NULL;
	int redisplay = 1;
	int modified = 0;
	int sec_shadowing = 0;
	int run_subkey_warnings = 0;
	int have_commands = !!commands;

	if (opt.command_fd != -1)
	;
	else if (opt.batch && !have_commands)
	{
	log_error (_("can't do this in batch mode\n"));
	goto leave;
	}

	#ifdef HAVE_W32_SYSTEM
	/* Due to Windows peculiarities we need to make sure that the
	trustdb stale check is done before we open another file
	(i.e. by searching for a key). In theory we could make sure
	that the files are closed after use but the open/close caches
	inhibits that and flushing the cache right before the stale
	check is not easy to implement. Thus we take the easy way out
	and run the stale check as early as possible. Note, that for
	non- W32 platforms it is run indirectly trough a call to
	get_validity (). */
	check_trustdb_stale (ctrl);
	#endif

	/* Get the public key */
	err = get_pubkey_byname (ctrl, GET_PUBKEY_NO_AKL,
	NULL, NULL, username, &keyblock, &kdbhd, 1);
	if (err)
	{
	log_error (_("key \"%s\" not found: %s\n"), username, gpg_strerror (err));
	goto leave;
	}

	if (fix_keyblock (ctrl, &keyblock))
	modified++;

	/* See whether we have a matching secret key. */
	if (seckey_check)
	{
	have_anyseckey = !agent_probe_any_secret_key (ctrl, keyblock);
	if (have_anyseckey
	&& !agent_probe_secret_key (ctrl, keyblock->pkt->pkt.public_key))
	{
	/* The primary key is also available. */
	have_seckey = 1;
	}

	if (have_seckey && !quiet)
	tty_printf (_("Secret key is available.\n"));
	else if (have_anyseckey && !quiet)
	tty_printf (_("Secret subkeys are available.\n"));
	}

	/* Main command loop. */
	for (;;)
	{
	int i, arg_number, photo;
	const char *arg_string = "";
	char *p;
	PKT_public_key *pk = keyblock->pkt->pkt.public_key;

	tty_printf ("\n");

	if (redisplay && !quiet)
	{
	/* Show using flags: with_revoker, with_subkeys. */
	show_key_with_all_names (ctrl, NULL, keyblock, 0, 1, 0, 1, 0, 0);
	tty_printf ("\n");
	redisplay = 0;
	}

	if (run_subkey_warnings)
	{
	run_subkey_warnings = 0;
	if (!count_selected_keys (keyblock))
	subkey_expire_warning (keyblock);
	}

	do
	{
	xfree (answer);
	if (have_commands)
	{
	if (commands)
	{
	answer = xstrdup (commands->d);
	commands = commands->next;
	}
	else if (opt.batch)
	{
	answer = xstrdup ("quit");
	}
	else
	have_commands = 0;
	}
	if (!have_commands)
	{
	#ifdef HAVE_LIBREADLINE
	tty_enable_completion (keyedit_completion);
	#endif
	answer = cpr_get_no_help ("keyedit.prompt", GPG_NAME "> ");
	cpr_kill_prompt ();
	tty_disable_completion ();
	}
	trim_spaces (answer);
	}
	while (*answer == '#');

	arg_number = 0; /* Here is the init which egcc complains about. */
	photo = 0; /* Same here. */
	if (!*answer)
	cmd = cmdLIST;
	else if (*answer == CONTROL_D)
	cmd = cmdQUIT;
	else if (digitp (answer))
	{
	cmd = cmdSELUID;
	arg_number = atoi (answer);
	}
	else
	{
	if ((p = strchr (answer, ' ')))
	{
	*p++ = 0;
	trim_spaces (answer);
	trim_spaces (p);
	arg_number = atoi (p);
	arg_string = p;
	}

	for (i = 0; cmds[i].name; i++)
	{
	if (cmds[i].flags & KEYEDIT_TAIL_MATCH)
	{
	size_t l = strlen (cmds[i].name);
	size_t a = strlen (answer);
	if (a >= l)
	{
	if (!ascii_strcasecmp (&answer[a - l], cmds[i].name))
	{
	answer[a - l] = '\0';
	break;
	}
	}
	}
	else if (!ascii_strcasecmp (answer, cmds[i].name))
	break;
	}
	if ((cmds[i].flags & (KEYEDIT_NEED_SK\|KEYEDIT_NEED_SUBSK))
	&& !(((cmds[i].flags & KEYEDIT_NEED_SK) && have_seckey)
	\|\| ((cmds[i].flags & KEYEDIT_NEED_SUBSK) && have_anyseckey)))
	{
	tty_printf (_("Need the secret key to do this.\n"));
	cmd = cmdNOP;
	}
	else
	cmd = cmds[i].id;
	}

	/* Dispatch the command. */
	switch (cmd)
	{
	case cmdHELP:
	for (i = 0; cmds[i].name; i++)
	{
	if ((cmds[i].flags & (KEYEDIT_NEED_SK\|KEYEDIT_NEED_SUBSK))
	&& !(((cmds[i].flags & KEYEDIT_NEED_SK) && have_seckey)
	\|\|((cmds[i].flags&KEYEDIT_NEED_SUBSK)&&have_anyseckey)))
	; /* Skip those item if we do not have the secret key. */
	else if (cmds[i].desc)
	tty_printf ("%-11s %s\n", cmds[i].name, _(cmds[i].desc));
	}

	tty_printf ("\n");
	tty_printf
	(_("* The 'sign' command may be prefixed with an 'l' for local "
	"signatures (lsign),\n"
	" a 't' for trust signatures (tsign), an 'nr' for "
	"non-revocable signatures\n"
	" (nrsign), or any combination thereof (ltsign, "
	"tnrsign, etc.).\n"));
	break;

	case cmdLIST:
	redisplay = 1;
	break;

	case cmdFPR:
	show_key_and_fingerprint
	(ctrl,
	keyblock, (arg_string == ''
	&& (!arg_string[1] \|\| spacep (arg_string + 1))));
	break;

	case cmdGRIP:
	show_key_and_grip (keyblock);
	break;

	case cmdSELUID:
	if (strlen (arg_string) == NAMEHASH_LEN * 2)
	redisplay = menu_select_uid_namehash (keyblock, arg_string);
	else
	{
	if (arg_string == ''
	&& (!arg_string[1] \|\| spacep (arg_string + 1)))
	arg_number = -1; /* Select all. */
	redisplay = menu_select_uid (keyblock, arg_number);
	}
	break;

	case cmdSELKEY:
	{
	if (arg_string == ''
	&& (!arg_string[1] \|\| spacep (arg_string + 1)))
	arg_number = -1; /* Select all. */
	if (menu_select_key (keyblock, arg_number, p))
	redisplay = 1;
	}
	break;

	case cmdCHECK:
	if (key_check_all_keysigs (ctrl, -1, keyblock,
	count_selected_uids (keyblock),
	!strcmp (arg_string, "selfsig")))
	modified = 1;
	break;

	case cmdSIGN:
	{
	int localsig = 0, nonrevokesig = 0, trustsig = 0, interactive = 0;

	if (pk->flags.revoked)
	{
	tty_printf (_("Key is revoked."));

	if (opt.expert)
	{
	tty_printf (" ");
	if (!cpr_get_answer_is_yes
	("keyedit.sign_revoked.okay",
	_("Are you sure you still want to sign it? (y/N) ")))
	break;
	}
	else
	{
	tty_printf (_(" Unable to sign.\n"));
	break;
	}
	}

	if (count_uids (keyblock) > 1 && !count_selected_uids (keyblock))
	{
	int result;
	if (opt.only_sign_text_ids)
	result = cpr_get_answer_is_yes
	("keyedit.sign_all.okay",
	_("Really sign all text user IDs? (y/N) "));
	else
	result = cpr_get_answer_is_yes
	("keyedit.sign_all.okay",
	_("Really sign all user IDs? (y/N) "));

	if (! result)
	{
	if (opt.interactive)
	interactive = 1;
	else
	{
	tty_printf (_("Hint: Select the user IDs to sign\n"));
	have_commands = 0;
	break;
	}

	}
	}
	/* What sort of signing are we doing? */
	if (!parse_sign_type
	(answer, &localsig, &nonrevokesig, &trustsig))
	{
	tty_printf (_("Unknown signature type '%s'\n"), answer);
	break;
	}

	sign_uids (ctrl, NULL, keyblock, locusr, &modified,
	localsig, nonrevokesig, trustsig, interactive, 0);
	}
	break;

	case cmdDEBUG:
	dump_kbnode (keyblock);
	break;

	case cmdTOGGLE:
	/* The toggle command is a leftover from old gpg versions
	where we worked with a secret and a public keyring. It
	is not necessary anymore but we keep this command for the
	sake of scripts using it. */
	redisplay = 1;
	break;

	case cmdADDPHOTO:
	if (RFC2440)
	{
	tty_printf (_("This command is not allowed while in %s mode.\n"),
	gnupg_compliance_option_string (opt.compliance));
	break;
	}
	photo = 1;
	/* fall through */
	case cmdADDUID:
	if (menu_adduid (ctrl, keyblock, photo, arg_string, NULL))
	{
	update_trust = 1;
	redisplay = 1;
	modified = 1;
	merge_keys_and_selfsig (ctrl, keyblock);
	}
	break;

	case cmdDELUID:
	{
	int n1;

	if (!(n1 = count_selected_uids (keyblock)))
	{
	tty_printf (_("You must select at least one user ID.\n"));
	if (!opt.expert)
	tty_printf (_("(Use the '%s' command.)\n"), "uid");
	}
	else if (real_uids_left (keyblock) < 1)
	tty_printf (_("You can't delete the last user ID!\n"));
	else if (cpr_get_answer_is_yes
	("keyedit.remove.uid.okay",
	n1 > 1 ? _("Really remove all selected user IDs? (y/N) ")
	: _("Really remove this user ID? (y/N) ")))
	{
	menu_deluid (keyblock);
	redisplay = 1;
	modified = 1;
	}
	}
	break;

	case cmdDELSIG:
	{
	int n1;

	if (!(n1 = count_selected_uids (keyblock)))
	{
	tty_printf (_("You must select at least one user ID.\n"));
	if (!opt.expert)
	tty_printf (_("(Use the '%s' command.)\n"), "uid");
	}
	else if (menu_delsig (ctrl, keyblock))
	{
	/* No redisplay here, because it may scroll away some
	* of the status output of this command. */
	modified = 1;
	}
	}
	break;

	case cmdADDKEY:
	if (!generate_subkeypair (ctrl, keyblock, NULL, NULL, NULL))
	{
	redisplay = 1;
	modified = 1;
	merge_keys_and_selfsig (ctrl, keyblock);
	}
	break;

	#ifdef ENABLE_CARD_SUPPORT
	case cmdADDCARDKEY:
	if (!card_generate_subkey (ctrl, keyblock))
	{
	redisplay = 1;
	modified = 1;
	merge_keys_and_selfsig (ctrl, keyblock);
	}
	break;

	case cmdKEYTOCARD:
	{
	KBNODE node = NULL;
	switch (count_selected_keys (keyblock))
	{
	case 0:
	if (cpr_get_answer_is_yes
	("keyedit.keytocard.use_primary",
	/* TRANSLATORS: Please take care: This is about
	moving the key and not about removing it. */
	_("Really move the primary key? (y/N) ")))
	node = keyblock;
	break;
	case 1:
	for (node = keyblock; node; node = node->next)
	{
	if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY
	&& node->flag & NODFLG_SELKEY)
	break;
	}
	break;
	default:
	tty_printf (_("You must select exactly one key.\n"));
	break;
	}
	if (node)
	{
	PKT_public_key *xxpk = node->pkt->pkt.public_key;
	if (card_store_subkey (node, xxpk ? xxpk->pubkey_usage : 0))
	{
	redisplay = 1;
	sec_shadowing = 1;
	}
	}
	}
	break;

	case cmdBKUPTOCARD:
	{
	/* Ask for a filename, check whether this is really a
	backup key as generated by the card generation, parse
	that key and store it on card. */
	KBNODE node;
	char *fname;
	PACKET *pkt;
	IOBUF a;
	struct parse_packet_ctx_s parsectx;

	if (!*arg_string)
	{
	tty_printf (_("Command expects a filename argument\n"));
	break;
	}

	if (*arg_string == DIRSEP_C)
	fname = xstrdup (arg_string);
	else if (*arg_string == '~')
	fname = make_filename (arg_string, NULL);
	else
	fname = make_filename (gnupg_homedir (), arg_string, NULL);

	/* Open that file. */
	a = iobuf_open (fname);
	if (a && is_secured_file (iobuf_get_fd (a)))
	{
	iobuf_close (a);
	a = NULL;
	gpg_err_set_errno (EPERM);
	}
	if (!a)
	{
	tty_printf (_("Can't open '%s': %s\n"),
	fname, strerror (errno));
	xfree (fname);
	break;
	}

	/* Parse and check that file. */
	pkt = xmalloc (sizeof *pkt);
	init_packet (pkt);
	init_parse_packet (&parsectx, a);
	err = parse_packet (&parsectx, pkt);
	deinit_parse_packet (&parsectx);
	iobuf_close (a);
	iobuf_ioctl (NULL, IOBUF_IOCTL_INVALIDATE_CACHE, 0, (char *) fname);
	if (!err && pkt->pkttype != PKT_SECRET_KEY
	&& pkt->pkttype != PKT_SECRET_SUBKEY)
	err = GPG_ERR_NO_SECKEY;
	if (err)
	{
	tty_printf (_("Error reading backup key from '%s': %s\n"),
	fname, gpg_strerror (err));
	xfree (fname);
	free_packet (pkt, NULL);
	xfree (pkt);
	break;
	}

	xfree (fname);
	node = new_kbnode (pkt);

	/* Transfer it to gpg-agent which handles secret keys. */
	err = transfer_secret_keys (ctrl, NULL, node, 1, 1, 0);

	/* Treat the pkt as a public key. */
	pkt->pkttype = PKT_PUBLIC_KEY;

	/* Ask gpg-agent to store the secret key to card. */
	if (card_store_subkey (node, 0))
	{
	redisplay = 1;
	sec_shadowing = 1;
	}
	release_kbnode (node);
	}
	break;

	#endif /* ENABLE_CARD_SUPPORT */

	case cmdDELKEY:
	{
	int n1;

	if (!(n1 = count_selected_keys (keyblock)))
	{
	tty_printf (_("You must select at least one key.\n"));
	if (!opt.expert)
	tty_printf (_("(Use the '%s' command.)\n"), "key");
	}
	else if (!cpr_get_answer_is_yes
	("keyedit.remove.subkey.okay",
	n1 > 1 ? _("Do you really want to delete the "
	"selected keys? (y/N) ")
	: _("Do you really want to delete this key? (y/N) ")))
	;
	else
	{
	menu_delkey (keyblock);
	redisplay = 1;
	modified = 1;
	}
	}
	break;

	case cmdADDREVOKER:
	{
	int sensitive = 0;

	if (ascii_strcasecmp (arg_string, "sensitive") == 0)
	sensitive = 1;
	if (menu_addrevoker (ctrl, keyblock, sensitive))
	{
	redisplay = 1;
	modified = 1;
	merge_keys_and_selfsig (ctrl, keyblock);
	}
	}
	break;

	case cmdREVUID:
	{
	int n1;

	if (!(n1 = count_selected_uids (keyblock)))
	{
	tty_printf (_("You must select at least one user ID.\n"));
	if (!opt.expert)
	tty_printf (_("(Use the '%s' command.)\n"), "uid");
	}
	else if (cpr_get_answer_is_yes
	("keyedit.revoke.uid.okay",
	n1 > 1 ? _("Really revoke all selected user IDs? (y/N) ")
	: _("Really revoke this user ID? (y/N) ")))
	{
	if (menu_revuid (ctrl, keyblock))
	{
	modified = 1;
	redisplay = 1;
	}
	}
	}
	break;

	case cmdREVKEY:
	{
	int n1;

	if (!(n1 = count_selected_keys (keyblock)))
	{
	if (cpr_get_answer_is_yes ("keyedit.revoke.subkey.okay",
	_("Do you really want to revoke"
	" the entire key? (y/N) ")))
	{
	if (menu_revkey (ctrl, keyblock))
	modified = 1;

	redisplay = 1;
	}
	}
	else if (cpr_get_answer_is_yes ("keyedit.revoke.subkey.okay",
	n1 > 1 ?
	_("Do you really want to revoke"
	" the selected subkeys? (y/N) ")
	: _("Do you really want to revoke"
	" this subkey? (y/N) ")))
	{
	if (menu_revsubkey (ctrl, keyblock))
	modified = 1;

	redisplay = 1;
	}

	if (modified)
	merge_keys_and_selfsig (ctrl, keyblock);
	}
	break;

	case cmdEXPIRE:
	if (gpg_err_code (menu_expire (ctrl, keyblock, 0, 0)) == GPG_ERR_TRUE)
	{
	merge_keys_and_selfsig (ctrl, keyblock);
	run_subkey_warnings = 1;
	modified = 1;
	redisplay = 1;
	}
	break;

	case cmdCHANGEUSAGE:
	if (menu_changeusage (ctrl, keyblock))
	{
	merge_keys_and_selfsig (ctrl, keyblock);
	modified = 1;
	redisplay = 1;
	}
	break;

	case cmdBACKSIGN:
	if (menu_backsign (ctrl, keyblock))
	{
	modified = 1;
	redisplay = 1;
	}
	break;

	case cmdPRIMARY:
	if (menu_set_primary_uid (ctrl, keyblock))
	{
	merge_keys_and_selfsig (ctrl, keyblock);
	modified = 1;
	redisplay = 1;
	}
	break;

	case cmdPASSWD:
	change_passphrase (ctrl, keyblock);
	break;

	#ifndef NO_TRUST_MODELS
	case cmdTRUST:
	if (opt.trust_model == TM_EXTERNAL)
	{
	tty_printf (_("Owner trust may not be set while "
	"using a user provided trust database\n"));
	break;
	}

	show_key_with_all_names (ctrl, NULL, keyblock, 0, 0, 0, 1, 0, 0);
	tty_printf ("\n");
	if (edit_ownertrust (ctrl, find_kbnode (keyblock,
	PKT_PUBLIC_KEY)->pkt->pkt.
	public_key, 1))
	{
	redisplay = 1;
	/* No real need to set update_trust here as
	edit_ownertrust() calls revalidation_mark()
	anyway. */
	update_trust = 1;
	}
	break;
	#endif /!NO_TRUST_MODELS/

	case cmdPREF:
	{
	int count = count_selected_uids (keyblock);
	log_assert (keyblock->pkt->pkttype == PKT_PUBLIC_KEY);
	show_names (ctrl, NULL, keyblock, keyblock->pkt->pkt.public_key,
	count ? NODFLG_SELUID : 0, 1);
	}
	break;

	case cmdSHOWPREF:
	{
	int count = count_selected_uids (keyblock);
	log_assert (keyblock->pkt->pkttype == PKT_PUBLIC_KEY);
	show_names (ctrl, NULL, keyblock, keyblock->pkt->pkt.public_key,
	count ? NODFLG_SELUID : 0, 2);
	}
	break;

	case cmdSETPREF:
	{
	PKT_user_id *tempuid;

	keygen_set_std_prefs (!*arg_string ? "default" : arg_string, 0);

	tempuid = keygen_get_std_prefs ();
	tty_printf (_("Set preference list to:\n"));
	show_prefs (tempuid, NULL, 1);
	free_user_id (tempuid);

	if (cpr_get_answer_is_yes
	("keyedit.setpref.okay",
	count_selected_uids (keyblock) ?
	_("Really update the preferences"
	" for the selected user IDs? (y/N) ")
	: _("Really update the preferences? (y/N) ")))
	{
	if (menu_set_preferences (ctrl, keyblock))
	{
	merge_keys_and_selfsig (ctrl, keyblock);
	modified = 1;
	redisplay = 1;
	}
	}
	}
	break;

	case cmdPREFKS:
	if (menu_set_keyserver_url (ctrl, *arg_string ? arg_string : NULL,
	keyblock))
	{
	merge_keys_and_selfsig (ctrl, keyblock);
	modified = 1;
	redisplay = 1;
	}
	break;

	case cmdNOTATION:
	if (menu_set_notation (ctrl, *arg_string ? arg_string : NULL,
	keyblock))
	{
	merge_keys_and_selfsig (ctrl, keyblock);
	modified = 1;
	redisplay = 1;
	}
	break;

	case cmdNOP:
	break;

	case cmdREVSIG:
	if (menu_revsig (ctrl, keyblock))
	{
	redisplay = 1;
	modified = 1;
	}
	break;

	#ifndef NO_TRUST_MODELS
	case cmdENABLEKEY:
	case cmdDISABLEKEY:
	if (enable_disable_key (ctrl, keyblock, cmd == cmdDISABLEKEY))
	{
	redisplay = 1;
	modified = 1;
	}
	break;
	#endif /!NO_TRUST_MODELS/

	case cmdSHOWPHOTO:
	menu_showphoto (ctrl, keyblock);
	break;

	case cmdCLEAN:
	if (menu_clean (ctrl, keyblock, 0))
	redisplay = modified = 1;
	break;

	case cmdMINIMIZE:
	if (menu_clean (ctrl, keyblock, 1))
	redisplay = modified = 1;
	break;

	case cmdQUIT:
	if (have_commands)
	goto leave;
	if (!modified && !sec_shadowing)
	goto leave;
	if (!cpr_get_answer_is_yes ("keyedit.save.okay",
	_("Save changes? (y/N) ")))
	{
	if (cpr_enabled ()
	\|\| cpr_get_answer_is_yes ("keyedit.cancel.okay",
	_("Quit without saving? (y/N) ")))
	goto leave;
	break;
	}
	/* fall through */
	case cmdSAVE:
	if (modified)
	{
	err = keydb_update_keyblock (ctrl, kdbhd, keyblock);
	if (err)
	{
	log_error (_("update failed: %s\n"), gpg_strerror (err));
	break;
	}
	}

	if (sec_shadowing)
	{
	err = agent_scd_learn (NULL, 1);
	if (err)
	{
	log_error (_("update failed: %s\n"), gpg_strerror (err));
	break;
	}
	}

	if (!modified && !sec_shadowing)
	tty_printf (_("Key not changed so no update needed.\n"));

	if (update_trust)
	{
	revalidation_mark (ctrl);
	update_trust = 0;
	}
	goto leave;

	case cmdINVCMD:
	default:
	tty_printf ("\n");
	tty_printf (_("Invalid command (try \"help\")\n"));
	break;
	}
	} /* End of the main command loop. */

	leave:
	release_kbnode (keyblock);
	keydb_release (kdbhd);
	xfree (answer);
	}


	/* Change the passphrase of the secret key identified by USERNAME. */
	void
	keyedit_passwd (ctrl_t ctrl, const char *username)
	{
	gpg_error_t err;
	PKT_public_key *pk;
	kbnode_t keyblock = NULL;

	pk = xtrycalloc (1, sizeof *pk);
	if (!pk)
	{
	err = gpg_error_from_syserror ();
	goto leave;
	}
	err = getkey_byname (ctrl, NULL, pk, username, 1, &keyblock);
	if (err)
	goto leave;

	err = change_passphrase (ctrl, keyblock);

	leave:
	release_kbnode (keyblock);
	free_public_key (pk);
	if (err)
	{
	log_info ("error changing the passphrase for '%s': %s\n",
	username, gpg_strerror (err));
	write_status_error ("keyedit.passwd", err);
	}
	else
	write_status_text (STATUS_SUCCESS, "keyedit.passwd");
	}


	/* Helper for quick commands to find the keyblock for USERNAME.
	* Returns on success the key database handle at R_KDBHD and the
	* keyblock at R_KEYBLOCK. */
	static gpg_error_t
	quick_find_keyblock (ctrl_t ctrl, const char *username,
	KEYDB_HANDLE r_kdbhd, kbnode_t r_keyblock)
	{
	gpg_error_t err;
	KEYDB_HANDLE kdbhd = NULL;
	kbnode_t keyblock = NULL;
	KEYDB_SEARCH_DESC desc;
	kbnode_t node;

	*r_kdbhd = NULL;
	*r_keyblock = NULL;

	/* Search the key; we don't want the whole getkey stuff here. */
	kdbhd = keydb_new ();
	if (!kdbhd)
	{
	/* Note that keydb_new has already used log_error. */
	err = gpg_error_from_syserror ();
	goto leave;
	}

	err = classify_user_id (username, &desc, 1);
	if (!err)
	err = keydb_search (kdbhd, &desc, 1, NULL);
	if (!err)
	{
	err = keydb_get_keyblock (kdbhd, &keyblock);
	if (err)
	{
	log_error (_("error reading keyblock: %s\n"), gpg_strerror (err));
	goto leave;
	}
	/* Now with the keyblock retrieved, search again to detect an
	ambiguous specification. We need to save the found state so
	that we can do an update later. */
	keydb_push_found_state (kdbhd);
	err = keydb_search (kdbhd, &desc, 1, NULL);
	if (!err)
	err = gpg_error (GPG_ERR_AMBIGUOUS_NAME);
	else if (gpg_err_code (err) == GPG_ERR_NOT_FOUND)
	err = 0;
	keydb_pop_found_state (kdbhd);

	if (!err)
	{
	/* We require the secret primary key to set the primary UID. */
	node = find_kbnode (keyblock, PKT_PUBLIC_KEY);
	log_assert (node);
	err = agent_probe_secret_key (ctrl, node->pkt->pkt.public_key);
	}
	}
	else if (gpg_err_code (err) == GPG_ERR_NOT_FOUND)
	err = gpg_error (GPG_ERR_NO_PUBKEY);

	if (err)
	{
	log_error (_("key \"%s\" not found: %s\n"),
	username, gpg_strerror (err));
	goto leave;
	}

	fix_keyblock (ctrl, &keyblock);
	merge_keys_and_selfsig (ctrl, keyblock);

	*r_keyblock = keyblock;
	keyblock = NULL;
	*r_kdbhd = kdbhd;
	kdbhd = NULL;

	leave:
	release_kbnode (keyblock);
	keydb_release (kdbhd);
	return err;
	}


	/* Unattended adding of a new keyid. USERNAME specifies the
	key. NEWUID is the new user id to add to the key. */
	void
	keyedit_quick_adduid (ctrl_t ctrl, const char username, const char newuid)
	{
	gpg_error_t err;
	KEYDB_HANDLE kdbhd = NULL;
	kbnode_t keyblock = NULL;
	char *uidstring = NULL;

	uidstring = xstrdup (newuid);
	trim_spaces (uidstring);
	if (!*uidstring)
	{
	log_error ("%s\n", gpg_strerror (GPG_ERR_INV_USER_ID));
	goto leave;
	}

	#ifdef HAVE_W32_SYSTEM
	/* See keyedit_menu for why we need this. */
	check_trustdb_stale (ctrl);
	#endif

	/* Search the key; we don't want the whole getkey stuff here. */
	err = quick_find_keyblock (ctrl, username, &kdbhd, &keyblock);
	if (err)
	goto leave;

	if (menu_adduid (ctrl, keyblock, 0, NULL, uidstring))
	{
	err = keydb_update_keyblock (ctrl, kdbhd, keyblock);
	if (err)
	{
	log_error (_("update failed: %s\n"), gpg_strerror (err));
	goto leave;
	}

	if (update_trust)
	revalidation_mark (ctrl);
	}

	leave:
	xfree (uidstring);
	release_kbnode (keyblock);
	keydb_release (kdbhd);
	}


	/* Unattended revocation of a keyid. USERNAME specifies the
	key. UIDTOREV is the user id revoke from the key. */
	void
	keyedit_quick_revuid (ctrl_t ctrl, const char username, const char uidtorev)
	{
	gpg_error_t err;
	KEYDB_HANDLE kdbhd = NULL;
	kbnode_t keyblock = NULL;
	kbnode_t node;
	int modified = 0;
	size_t revlen;
	size_t valid_uids;

	#ifdef HAVE_W32_SYSTEM
	/* See keyedit_menu for why we need this. */
	check_trustdb_stale (ctrl);
	#endif

	/* Search the key; we don't want the whole getkey stuff here. */
	err = quick_find_keyblock (ctrl, username, &kdbhd, &keyblock);
	if (err)
	goto leave;

	/* Too make sure that we do not revoke the last valid UID, we first
	count how many valid UIDs there are. */
	valid_uids = 0;
	for (node = keyblock; node; node = node->next)
	valid_uids += (node->pkt->pkttype == PKT_USER_ID
	&& !node->pkt->pkt.user_id->flags.revoked
	&& !node->pkt->pkt.user_id->flags.expired);

	/* Find the right UID. */
	revlen = strlen (uidtorev);
	for (node = keyblock; node; node = node->next)
	{
	if (node->pkt->pkttype == PKT_USER_ID
	&& revlen == node->pkt->pkt.user_id->len
	&& !memcmp (node->pkt->pkt.user_id->name, uidtorev, revlen))
	{
	struct revocation_reason_info *reason;

	/* Make sure that we do not revoke the last valid UID. */
	if (valid_uids == 1
	&& ! node->pkt->pkt.user_id->flags.revoked
	&& ! node->pkt->pkt.user_id->flags.expired)
	{
	log_error (_("cannot revoke the last valid user ID.\n"));
	err = gpg_error (GPG_ERR_INV_USER_ID);
	goto leave;
	}

	reason = get_default_uid_revocation_reason ();
	err = core_revuid (ctrl, keyblock, node, reason, &modified);
	release_revocation_reason_info (reason);
	if (err)
	goto leave;
	err = keydb_update_keyblock (ctrl, kdbhd, keyblock);
	if (err)
	{
	log_error (_("update failed: %s\n"), gpg_strerror (err));
	goto leave;
	}

	revalidation_mark (ctrl);
	goto leave;
	}
	}
	err = gpg_error (GPG_ERR_NO_USER_ID);


	leave:
	if (err)
	{
	log_error (_("revoking the user ID failed: %s\n"), gpg_strerror (err));
	write_status_error ("keyedit.revoke.uid", err);
	}
	release_kbnode (keyblock);
	keydb_release (kdbhd);
	}


	/* Unattended setting of the primary uid. USERNAME specifies the key.
	PRIMARYUID is the user id which shall be primary. */
	void
	keyedit_quick_set_primary (ctrl_t ctrl, const char *username,
	const char *primaryuid)
	{
	gpg_error_t err;
	KEYDB_HANDLE kdbhd = NULL;
	kbnode_t keyblock = NULL;
	kbnode_t node;
	size_t primaryuidlen;
	int any;

	#ifdef HAVE_W32_SYSTEM
	/* See keyedit_menu for why we need this. */
	check_trustdb_stale (ctrl);
	#endif

	err = quick_find_keyblock (ctrl, username, &kdbhd, &keyblock);
	if (err)
	goto leave;

	/* Find and mark the UID - we mark only the first valid one. */
	primaryuidlen = strlen (primaryuid);
	any = 0;
	for (node = keyblock; node; node = node->next)
	{
	if (node->pkt->pkttype == PKT_USER_ID
	&& !any
	&& !node->pkt->pkt.user_id->flags.revoked
	&& !node->pkt->pkt.user_id->flags.expired
	&& primaryuidlen == node->pkt->pkt.user_id->len
	&& !memcmp (node->pkt->pkt.user_id->name, primaryuid, primaryuidlen))
	{
	node->flag \|= NODFLG_SELUID;
	any = 1;
	}
	else
	node->flag &= ~NODFLG_SELUID;
	}

	if (!any)
	err = gpg_error (GPG_ERR_NO_USER_ID);
	else if (menu_set_primary_uid (ctrl, keyblock))
	{
	merge_keys_and_selfsig (ctrl, keyblock);
	err = keydb_update_keyblock (ctrl, kdbhd, keyblock);
	if (err)
	{
	log_error (_("update failed: %s\n"), gpg_strerror (err));
	goto leave;
	}
	revalidation_mark (ctrl);
	}
	else
	err = gpg_error (GPG_ERR_GENERAL);

	if (err)
	log_error (_("setting the primary user ID failed: %s\n"),
	gpg_strerror (err));

	leave:
	release_kbnode (keyblock);
	keydb_release (kdbhd);
	}


	/* Find a keyblock by fingerprint because only this uniquely
	* identifies a key and may thus be used to select a key for
	* unattended subkey creation os key signing. */
	static gpg_error_t
	find_by_primary_fpr (ctrl_t ctrl, const char *fpr,
	kbnode_t r_keyblock, KEYDB_HANDLE r_kdbhd)
	{
	gpg_error_t err;
	kbnode_t keyblock = NULL;
	KEYDB_HANDLE kdbhd = NULL;
	KEYDB_SEARCH_DESC desc;
	byte fprbin[MAX_FINGERPRINT_LEN];
	size_t fprlen;

	*r_keyblock = NULL;
	*r_kdbhd = NULL;

	if (classify_user_id (fpr, &desc, 1)
	\|\| !(desc.mode == KEYDB_SEARCH_MODE_FPR
	\|\| desc.mode == KEYDB_SEARCH_MODE_FPR16
	\|\| desc.mode == KEYDB_SEARCH_MODE_FPR20))
	{
	log_error (_("\"%s\" is not a fingerprint\n"), fpr);
	err = gpg_error (GPG_ERR_INV_NAME);
	goto leave;
	}
	err = get_pubkey_byname (ctrl, GET_PUBKEY_NO_AKL,
	NULL, NULL, fpr, &keyblock, &kdbhd, 1);
	if (err)
	{
	log_error (_("key \"%s\" not found: %s\n"), fpr, gpg_strerror (err));
	goto leave;
	}

	/* Check that the primary fingerprint has been given. */
	fingerprint_from_pk (keyblock->pkt->pkt.public_key, fprbin, &fprlen);
	if (fprlen == 16 && desc.mode == KEYDB_SEARCH_MODE_FPR16
	&& !memcmp (fprbin, desc.u.fpr, 16))
	;
	else if (fprlen == 16 && desc.mode == KEYDB_SEARCH_MODE_FPR
	&& !memcmp (fprbin, desc.u.fpr, 16)
	&& !desc.u.fpr[16]
	&& !desc.u.fpr[17]
	&& !desc.u.fpr[18]
	&& !desc.u.fpr[19])
	;
	else if (fprlen == 20 && (desc.mode == KEYDB_SEARCH_MODE_FPR20
	\|\| desc.mode == KEYDB_SEARCH_MODE_FPR)
	&& !memcmp (fprbin, desc.u.fpr, 20))
	;
	else
	{
	log_error (_("\"%s\" is not the primary fingerprint\n"), fpr);
	err = gpg_error (GPG_ERR_INV_NAME);
	goto leave;
	}

	*r_keyblock = keyblock;
	keyblock = NULL;
	*r_kdbhd = kdbhd;
	kdbhd = NULL;
	err = 0;

	leave:
	release_kbnode (keyblock);
	keydb_release (kdbhd);
	return err;
	}


	/* Unattended key signing function. If the key specifified by FPR is
	available and FPR is the primary fingerprint all user ids of the
	key are signed using the default signing key. If UIDS is an empty
	list all usable UIDs are signed, if it is not empty, only those
	user ids matching one of the entries of the list are signed. With
	LOCAL being true the signatures are marked as non-exportable. */
	void
	keyedit_quick_sign (ctrl_t ctrl, const char *fpr, strlist_t uids,
	strlist_t locusr, int local)
	{
	gpg_error_t err;
	kbnode_t keyblock = NULL;
	KEYDB_HANDLE kdbhd = NULL;
	int modified = 0;
	PKT_public_key *pk;
	kbnode_t node;
	strlist_t sl;
	int any;

	#ifdef HAVE_W32_SYSTEM
	/* See keyedit_menu for why we need this. */
	check_trustdb_stale (ctrl);
	#endif

	/* We require a fingerprint because only this uniquely identifies a
	key and may thus be used to select a key for unattended key
	signing. */
	if (find_by_primary_fpr (ctrl, fpr, &keyblock, &kdbhd))
	goto leave;

	if (fix_keyblock (ctrl, &keyblock))
	modified++;

	/* Give some info in verbose. */
	if (opt.verbose)
	{
	show_key_with_all_names (ctrl, es_stdout, keyblock, 0,
	1/with_revoker/, 1/with_fingerprint/,
	0, 0, 1);
	es_fflush (es_stdout);
	}

	pk = keyblock->pkt->pkt.public_key;
	if (pk->flags.revoked)
	{
	if (!opt.verbose)
	show_key_with_all_names (ctrl, es_stdout, keyblock, 0, 0, 0, 0, 0, 1);
	log_error ("%s%s", _("Key is revoked."), _(" Unable to sign.\n"));
	goto leave;
	}

	/* Set the flags according to the UIDS list. Fixme: We may want to
	use classify_user_id along with dedicated compare functions so
	that we match the same way as in the key lookup. */
	any = 0;
	menu_select_uid (keyblock, 0); /* Better clear the flags first. */
	for (sl=uids; sl; sl = sl->next)
	{
	const char *name = sl->d;
	int count = 0;

	sl->flags &= ~(1\|2); /* Clear flags used for error reporting. */

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

	if (uid->attrib_data)
	;
	else if (*name == '='
	&& strlen (name+1) == uid->len
	&& !memcmp (uid->name, name + 1, uid->len))
	{ /* Exact match - we don't do a check for ambiguity
	* in this case. */
	node->flag \|= NODFLG_SELUID;
	if (any != -1)
	{
	sl->flags \|= 1; /* Report as found. */
	any = 1;
	}
	}
	else if (ascii_memistr (uid->name, uid->len,
	name == ''? name+1:name))
	{
	node->flag \|= NODFLG_SELUID;
	if (any != -1)
	{
	sl->flags \|= 1; /* Report as found. */
	any = 1;
	}
	count++;
	}
	}
	}

	if (count > 1)
	{
	any = -1; /* Force failure at end. */
	sl->flags \|= 2; /* Report as ambiguous. */
	}
	}

	/* Check whether all given user ids were found. */
	for (sl=uids; sl; sl = sl->next)
	if (!(sl->flags & 1))
	any = -1; /* That user id was not found. */

	/* Print an error if there was a problem with the user ids. */
	if (uids && any < 1)
	{
	if (!opt.verbose)
	show_key_with_all_names (ctrl, es_stdout, keyblock, 0, 0, 0, 0, 0, 1);
	es_fflush (es_stdout);
	for (sl=uids; sl; sl = sl->next)
	{
	if ((sl->flags & 2))
	log_info (_("Invalid user ID '%s': %s\n"),
	sl->d, gpg_strerror (GPG_ERR_AMBIGUOUS_NAME));
	else if (!(sl->flags & 1))
	log_info (_("Invalid user ID '%s': %s\n"),
	sl->d, gpg_strerror (GPG_ERR_NOT_FOUND));
	}
	log_error ("%s %s", _("No matching user IDs."), _("Nothing to sign.\n"));
	goto leave;
	}

	/* Sign. */
	sign_uids (ctrl, es_stdout, keyblock, locusr, &modified, local, 0, 0, 0, 1);
	es_fflush (es_stdout);

	if (modified)
	{
	err = keydb_update_keyblock (ctrl, kdbhd, keyblock);
	if (err)
	{
	log_error (_("update failed: %s\n"), gpg_strerror (err));
	goto leave;
	}
	}
	else
	log_info (_("Key not changed so no update needed.\n"));

	if (update_trust)
	revalidation_mark (ctrl);


	leave:
	release_kbnode (keyblock);
	keydb_release (kdbhd);
	}


	/* Unattended subkey creation function.
	*
	*/
	void
	keyedit_quick_addkey (ctrl_t ctrl, const char fpr, const char algostr,
	const char usagestr, const char expirestr)
	{
	gpg_error_t err;
	kbnode_t keyblock;
	KEYDB_HANDLE kdbhd;
	int modified = 0;
	PKT_public_key *pk;

	#ifdef HAVE_W32_SYSTEM
	/* See keyedit_menu for why we need this. */
	check_trustdb_stale (ctrl);
	#endif

	/* We require a fingerprint because only this uniquely identifies a
	* key and may thus be used to select a key for unattended subkey
	* creation. */
	if (find_by_primary_fpr (ctrl, fpr, &keyblock, &kdbhd))
	goto leave;

	if (fix_keyblock (ctrl, &keyblock))
	modified++;

	pk = keyblock->pkt->pkt.public_key;
	if (pk->flags.revoked)
	{
	if (!opt.verbose)
	show_key_with_all_names (ctrl, es_stdout, keyblock, 0, 0, 0, 0, 0, 1);
	log_error ("%s%s", _("Key is revoked."), "\n");
	goto leave;
	}

	/* Create the subkey. Note that the called function already prints
	* an error message. */
	if (!generate_subkeypair (ctrl, keyblock, algostr, usagestr, expirestr))
	modified = 1;
	es_fflush (es_stdout);

	/* Store. */
	if (modified)
	{
	err = keydb_update_keyblock (ctrl, kdbhd, keyblock);
	if (err)
	{
	log_error (_("update failed: %s\n"), gpg_strerror (err));
	goto leave;
	}
	}
	else
	log_info (_("Key not changed so no update needed.\n"));

	leave:
	release_kbnode (keyblock);
	keydb_release (kdbhd);
	}


	/* Unattended expiration setting function for the main key. If
	* SUBKEYFPRS is not NULL and SUBKEYSFPRS[0] is neither NULL, it is
	* expected to be an array of fingerprints for subkeys to change. It
	* may also be an array which just one item "*" to indicate that all
	* keys shall be set to that expiration date.
	*/
	void
	keyedit_quick_set_expire (ctrl_t ctrl, const char fpr, const char expirestr,
	char **subkeyfprs)
	{
	gpg_error_t err;
	kbnode_t keyblock, node;
	KEYDB_HANDLE kdbhd;
	int modified = 0;
	PKT_public_key *pk;
	u32 expire;
	int primary_only = 0;
	int idx;

	#ifdef HAVE_W32_SYSTEM
	/* See keyedit_menu for why we need this. */
	check_trustdb_stale (ctrl);
	#endif

	/* We require a fingerprint because only this uniquely identifies a
	* key and may thus be used to select a key for unattended
	* expiration setting. */
	err = find_by_primary_fpr (ctrl, fpr, &keyblock, &kdbhd);
	if (err)
	goto leave;

	if (fix_keyblock (ctrl, &keyblock))
	modified++;

	pk = keyblock->pkt->pkt.public_key;
	if (pk->flags.revoked)
	{
	if (!opt.verbose)
	show_key_with_all_names (ctrl, es_stdout, keyblock, 0, 0, 0, 0, 0, 1);
	log_error ("%s%s", _("Key is revoked."), "\n");
	err = gpg_error (GPG_ERR_CERT_REVOKED);
	goto leave;
	}

	expire = parse_expire_string (expirestr);
	if (expire == (u32)-1 )
	{
	log_error (_("'%s' is not a valid expiration time\n"), expirestr);
	err = gpg_error (GPG_ERR_INV_VALUE);
	goto leave;
	}
	if (expire)
	expire += make_timestamp ();

	/* Check whether a subkey's expiration time shall be changed or the
	* expiration time of all keys. */
	if (!subkeyfprs \|\| !subkeyfprs[0])
	primary_only = 1;
	else if ( !strcmp (subkeyfprs[0], "*") && !subkeyfprs[1])
	{
	/* Change all subkeys keys which have not been revoked and are
	* not yet expired. */
	merge_keys_and_selfsig (ctrl, keyblock);
	for (node = keyblock; node; node = node->next)
	{
	if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY
	&& (pk = node->pkt->pkt.public_key)
	&& !pk->flags.revoked
	&& !pk->has_expired)
	node->flag \|= NODFLG_SELKEY;
	}
	}
	else
	{
	/* Change specified subkeys. */
	KEYDB_SEARCH_DESC desc;
	byte fprbin[MAX_FINGERPRINT_LEN];
	size_t fprlen;

	err = 0;
	merge_keys_and_selfsig (ctrl, keyblock);
	for (idx=0; subkeyfprs[idx]; idx++)
	{
	int any = 0;

	/* Parse the fingerprint. */
	if (classify_user_id (subkeyfprs[idx], &desc, 1)
	\|\| !(desc.mode == KEYDB_SEARCH_MODE_FPR
	\|\| desc.mode == KEYDB_SEARCH_MODE_FPR20))
	{
	log_error (_("\"%s\" is not a proper fingerprint\n"),
	subkeyfprs[idx] );
	if (!err)
	err = gpg_error (GPG_ERR_INV_NAME);
	continue;
	}

	/* Set the flag for the matching non revoked subkey. */
	for (node = keyblock; node; node = node->next)
	{
	if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY
	&& (pk = node->pkt->pkt.public_key)
	&& !pk->flags.revoked )
	{
	fingerprint_from_pk (pk, fprbin, &fprlen);
	if (fprlen == 20 && !memcmp (fprbin, desc.u.fpr, 20))
	{
	node->flag \|= NODFLG_SELKEY;
	any = 1;
	}
	}
	}
	if (!any)
	{
	log_error (_("subkey \"%s\" not found\n"), subkeyfprs[idx]);
	if (!err)
	err = gpg_error (GPG_ERR_NOT_FOUND);
	}
	}

	if (err)
	goto leave;
	}

	/* Set the new expiration date. */
	err = menu_expire (ctrl, keyblock, primary_only? 1 : 2, expire);
	if (gpg_err_code (err) == GPG_ERR_TRUE)
	modified = 1;
	else if (err)
	goto leave;
	es_fflush (es_stdout);

	/* Store. */
	if (modified)
	{
	err = keydb_update_keyblock (ctrl, kdbhd, keyblock);
	if (err)
	{
	log_error (_("update failed: %s\n"), gpg_strerror (err));
	goto leave;
	}
	if (update_trust)
	revalidation_mark (ctrl);
	}
	else
	log_info (_("Key not changed so no update needed.\n"));

	leave:
	release_kbnode (keyblock);
	keydb_release (kdbhd);
	if (err)
	write_status_error ("set_expire", err);
	}



	static void
	tty_print_notations (int indent, PKT_signature * sig)
	{
	int first = 1;
	struct notation notation, nd;

	if (indent < 0)
	{
	first = 0;
	indent = -indent;
	}

	notation = sig_to_notation (sig);

	for (nd = notation; nd; nd = nd->next)
	{
	if (!first)
	tty_printf ("%*s", indent, "");
	else
	first = 0;

	tty_print_utf8_string (nd->name, strlen (nd->name));
	tty_printf ("=");
	tty_print_utf8_string (nd->value, strlen (nd->value));
	tty_printf ("\n");
	}

	free_notation (notation);
	}


	/*
	* Show preferences of a public keyblock.
	*/
	static void
	show_prefs (PKT_user_id * uid, PKT_signature * selfsig, int verbose)
	{
	const prefitem_t fake = { 0, 0 };
	const prefitem_t *prefs;
	int i;

	if (!uid)
	return;

	if (uid->prefs)
	prefs = uid->prefs;
	else if (verbose)
	prefs = &fake;
	else
	return;

	if (verbose)
	{
	int any, des_seen = 0, sha1_seen = 0, uncomp_seen = 0;

	tty_printf (" ");
	tty_printf (_("Cipher: "));
	for (i = any = 0; prefs[i].type; i++)
	{
	if (prefs[i].type == PREFTYPE_SYM)
	{
	if (any)
	tty_printf (", ");
	any = 1;
	/* We don't want to display strings for experimental algos */
	if (!openpgp_cipher_test_algo (prefs[i].value)
	&& prefs[i].value < 100)
	tty_printf ("%s", openpgp_cipher_algo_name (prefs[i].value));
	else
	tty_printf ("[%d]", prefs[i].value);
	if (prefs[i].value == CIPHER_ALGO_3DES)
	des_seen = 1;
	}
	}
	if (!des_seen)
	{
	if (any)
	tty_printf (", ");
	tty_printf ("%s", openpgp_cipher_algo_name (CIPHER_ALGO_3DES));
	}
	tty_printf ("\n ");
	+ tty_printf (_("AEAD: "));
	+ for (i = any = 0; prefs[i].type; i++)
	+ {
	+ if (prefs[i].type == PREFTYPE_AEAD)
	+ {
	+ if (any)
	+ tty_printf (", ");
	+ any = 1;
	+ /* We don't want to display strings for experimental algos */
	+ if (!openpgp_aead_test_algo (prefs[i].value)
	+ && prefs[i].value < 100)
	+ tty_printf ("%s", openpgp_aead_algo_name (prefs[i].value));
	+ else
	+ tty_printf ("[%d]", prefs[i].value);
	+ }
	+ }
	+ tty_printf ("\n ");
	tty_printf (_("Digest: "));
	for (i = any = 0; prefs[i].type; i++)
	{
	if (prefs[i].type == PREFTYPE_HASH)
	{
	if (any)
	tty_printf (", ");
	any = 1;
	/* We don't want to display strings for experimental algos */
	if (!gcry_md_test_algo (prefs[i].value) && prefs[i].value < 100)
	tty_printf ("%s", gcry_md_algo_name (prefs[i].value));
	else
	tty_printf ("[%d]", prefs[i].value);
	if (prefs[i].value == DIGEST_ALGO_SHA1)
	sha1_seen = 1;
	}
	}
	if (!sha1_seen)
	{
	if (any)
	tty_printf (", ");
	tty_printf ("%s", gcry_md_algo_name (DIGEST_ALGO_SHA1));
	}
	tty_printf ("\n ");
	tty_printf (_("Compression: "));
	for (i = any = 0; prefs[i].type; i++)
	{
	if (prefs[i].type == PREFTYPE_ZIP)
	{
	const char *s = compress_algo_to_string (prefs[i].value);

	if (any)
	tty_printf (", ");
	any = 1;
	/* We don't want to display strings for experimental algos */
	if (s && prefs[i].value < 100)
	tty_printf ("%s", s);
	else
	tty_printf ("[%d]", prefs[i].value);
	if (prefs[i].value == COMPRESS_ALGO_NONE)
	uncomp_seen = 1;
	}
	}
	if (!uncomp_seen)
	{
	if (any)
	tty_printf (", ");
	else
	{
	tty_printf ("%s", compress_algo_to_string (COMPRESS_ALGO_ZIP));
	tty_printf (", ");
	}
	tty_printf ("%s", compress_algo_to_string (COMPRESS_ALGO_NONE));
	}
	- if (uid->flags.mdc \|\| !uid->flags.ks_modify)
	+ if (uid->flags.mdc \|\| uid->flags.aead \|\| !uid->flags.ks_modify)
	{
	tty_printf ("\n ");
	tty_printf (_("Features: "));
	any = 0;
	if (uid->flags.mdc)
	{
	tty_printf ("MDC");
	any = 1;
	}
	+ if (!uid->flags.aead)
	+ {
	+ if (any)
	+ tty_printf (", ");
	+ tty_printf ("AEAD");
	+ }
	if (!uid->flags.ks_modify)
	{
	if (any)
	tty_printf (", ");
	tty_printf (_("Keyserver no-modify"));
	}
	}
	tty_printf ("\n");

	if (selfsig)
	{
	const byte *pref_ks;
	size_t pref_ks_len;

	pref_ks = parse_sig_subpkt (selfsig->hashed,
	SIGSUBPKT_PREF_KS, &pref_ks_len);
	if (pref_ks && pref_ks_len)
	{
	tty_printf (" ");
	tty_printf (_("Preferred keyserver: "));
	tty_print_utf8_string (pref_ks, pref_ks_len);
	tty_printf ("\n");
	}

	if (selfsig->flags.notation)
	{
	tty_printf (" ");
	tty_printf (_("Notations: "));
	tty_print_notations (5 + strlen (_("Notations: ")), selfsig);
	}
	}
	}
	else
	{
	tty_printf (" ");
	for (i = 0; prefs[i].type; i++)
	{
	tty_printf (" %c%d", prefs[i].type == PREFTYPE_SYM ? 'S' :
	+ prefs[i].type == PREFTYPE_AEAD ? 'A' :
	prefs[i].type == PREFTYPE_HASH ? 'H' :
	prefs[i].type == PREFTYPE_ZIP ? 'Z' : '?',
	prefs[i].value);
	}
	if (uid->flags.mdc)
	tty_printf (" [mdc]");
	+ if (uid->flags.aead)
	+ tty_printf (" [aead]");
	if (!uid->flags.ks_modify)
	tty_printf (" [no-ks-modify]");
	tty_printf ("\n");
	}
	}


	/* This is the version of show_key_with_all_names used when
	opt.with_colons is used. It prints all available data in a easy to
	parse format and does not translate utf8 */
	static void
	show_key_with_all_names_colon (ctrl_t ctrl, estream_t fp, kbnode_t keyblock)
	{
	KBNODE node;
	int i, j, ulti_hack = 0;
	byte pk_version = 0;
	PKT_public_key *primary = NULL;
	int have_seckey;

	if (!fp)
	fp = es_stdout;

	/* the keys */
	for (node = keyblock; node; node = node->next)
	{
	if (node->pkt->pkttype == PKT_PUBLIC_KEY
	\|\| (node->pkt->pkttype == PKT_PUBLIC_SUBKEY))
	{
	PKT_public_key *pk = node->pkt->pkt.public_key;
	u32 keyid[2];

	if (node->pkt->pkttype == PKT_PUBLIC_KEY)
	{
	pk_version = pk->version;
	primary = pk;
	}

	keyid_from_pk (pk, keyid);
	have_seckey = !agent_probe_secret_key (ctrl, pk);

	if (node->pkt->pkttype == PKT_PUBLIC_KEY)
	es_fputs (have_seckey? "sec:" : "pub:", fp);
	else
	es_fputs (have_seckey? "ssb:" : "sub:", fp);

	if (!pk->flags.valid)
	es_putc ('i', fp);
	else if (pk->flags.revoked)
	es_putc ('r', fp);
	else if (pk->has_expired)
	es_putc ('e', fp);
	else if (!(opt.fast_list_mode \|\| opt.no_expensive_trust_checks))
	{
	int trust = get_validity_info (ctrl, keyblock, pk, NULL);
	if (trust == 'u')
	ulti_hack = 1;
	es_putc (trust, fp);
	}

	es_fprintf (fp, ":%u:%d:%08lX%08lX:%lu:%lu::",
	nbits_from_pk (pk),
	pk->pubkey_algo,
	(ulong) keyid[0], (ulong) keyid[1],
	(ulong) pk->timestamp, (ulong) pk->expiredate);
	if (node->pkt->pkttype == PKT_PUBLIC_KEY
	&& !(opt.fast_list_mode \|\| opt.no_expensive_trust_checks))
	es_putc (get_ownertrust_info (ctrl, pk, 0), fp);
	es_putc (':', fp);
	es_putc (':', fp);
	es_putc (':', fp);
	/* Print capabilities. */
	if ((pk->pubkey_usage & PUBKEY_USAGE_ENC))
	es_putc ('e', fp);
	if ((pk->pubkey_usage & PUBKEY_USAGE_SIG))
	es_putc ('s', fp);
	if ((pk->pubkey_usage & PUBKEY_USAGE_CERT))
	es_putc ('c', fp);
	if ((pk->pubkey_usage & PUBKEY_USAGE_AUTH))
	es_putc ('a', fp);
	es_putc ('\n', fp);

	print_fingerprint (ctrl, fp, pk, 0);
	print_revokers (fp, pk);
	}
	}

	/* the user ids */
	i = 0;
	for (node = keyblock; node; node = node->next)
	{
	if (node->pkt->pkttype == PKT_USER_ID)
	{
	PKT_user_id *uid = node->pkt->pkt.user_id;

	++i;

	if (uid->attrib_data)
	es_fputs ("uat:", fp);
	else
	es_fputs ("uid:", fp);

	if (uid->flags.revoked)
	es_fputs ("r::::::::", fp);
	else if (uid->flags.expired)
	es_fputs ("e::::::::", fp);
	else if (opt.fast_list_mode \|\| opt.no_expensive_trust_checks)
	es_fputs ("::::::::", fp);
	else
	{
	int uid_validity;

	if (primary && !ulti_hack)
	uid_validity = get_validity_info (ctrl, keyblock, primary, uid);
	else
	uid_validity = 'u';
	es_fprintf (fp, "%c::::::::", uid_validity);
	}

	if (uid->attrib_data)
	es_fprintf (fp, "%u %lu", uid->numattribs, uid->attrib_len);
	else
	es_write_sanitized (fp, uid->name, uid->len, ":", NULL);

	es_putc (':', fp);
	/* signature class */
	es_putc (':', fp);
	/* capabilities */
	es_putc (':', fp);
	/* preferences */
	if (pk_version > 3 \|\| uid->selfsigversion > 3)
	{
	const prefitem_t *prefs = uid->prefs;

	for (j = 0; prefs && prefs[j].type; j++)
	{
	if (j)
	es_putc (' ', fp);
	es_fprintf (fp,
	"%c%d", prefs[j].type == PREFTYPE_SYM ? 'S' :
	prefs[j].type == PREFTYPE_HASH ? 'H' :
	prefs[j].type == PREFTYPE_ZIP ? 'Z' : '?',
	prefs[j].value);
	}
	if (uid->flags.mdc)
	es_fputs (",mdc", fp);
	if (!uid->flags.ks_modify)
	es_fputs (",no-ks-modify", fp);
	}
	es_putc (':', fp);
	/* flags */
	es_fprintf (fp, "%d,", i);
	if (uid->flags.primary)
	es_putc ('p', fp);
	if (uid->flags.revoked)
	es_putc ('r', fp);
	if (uid->flags.expired)
	es_putc ('e', fp);
	if ((node->flag & NODFLG_SELUID))
	es_putc ('s', fp);
	if ((node->flag & NODFLG_MARK_A))
	es_putc ('m', fp);
	es_putc (':', fp);
	if (opt.trust_model == TM_TOFU \|\| opt.trust_model == TM_TOFU_PGP)
	{
	#ifdef USE_TOFU
	enum tofu_policy policy;
	if (! tofu_get_policy (ctrl, primary, uid, &policy)
	&& policy != TOFU_POLICY_NONE)
	es_fprintf (fp, "%s", tofu_policy_str (policy));
	#endif /USE_TOFU/
	}
	es_putc (':', fp);
	es_putc ('\n', fp);
	}
	}
	}


	static void
	show_names (ctrl_t ctrl, estream_t fp,
	kbnode_t keyblock, PKT_public_key * pk, unsigned int flag,
	int with_prefs)
	{
	KBNODE node;
	int i = 0;

	for (node = keyblock; node; node = node->next)
	{
	if (node->pkt->pkttype == PKT_USER_ID && !is_deleted_kbnode (node))
	{
	PKT_user_id *uid = node->pkt->pkt.user_id;
	++i;
	if (!flag \|\| (flag && (node->flag & flag)))
	{
	if (!(flag & NODFLG_MARK_A) && pk)
	tty_fprintf (fp, "%s ", uid_trust_string_fixed (ctrl, pk, uid));

	if (flag & NODFLG_MARK_A)
	tty_fprintf (fp, " ");
	else if (node->flag & NODFLG_SELUID)
	tty_fprintf (fp, "(%d)* ", i);
	else if (uid->flags.primary)
	tty_fprintf (fp, "(%d). ", i);
	else
	tty_fprintf (fp, "(%d) ", i);
	tty_print_utf8_string2 (fp, uid->name, uid->len, 0);
	tty_fprintf (fp, "\n");
	if (with_prefs && pk)
	{
	if (pk->version > 3 \|\| uid->selfsigversion > 3)
	{
	PKT_signature *selfsig = NULL;
	KBNODE signode;

	for (signode = node->next;
	signode && signode->pkt->pkttype == PKT_SIGNATURE;
	signode = signode->next)
	{
	if (signode->pkt->pkt.signature->
	flags.chosen_selfsig)
	{
	selfsig = signode->pkt->pkt.signature;
	break;
	}
	}

	show_prefs (uid, selfsig, with_prefs == 2);
	}
	else
	tty_fprintf (fp, _("There are no preferences on a"
	" PGP 2.x-style user ID.\n"));
	}
	}
	}
	}
	}


	/*
	* Display the key a the user ids, if only_marked is true, do only so
	* for user ids with mark A flag set and do not display the index
	* number. If FP is not NULL print to the given stream and not to the
	* tty (ignored in with-colons mode).
	*/
	static void
	show_key_with_all_names (ctrl_t ctrl, estream_t fp,
	KBNODE keyblock, int only_marked, int with_revoker,
	int with_fpr, int with_subkeys, int with_prefs,
	int nowarn)
	{
	gpg_error_t err;
	kbnode_t node;
	int i;
	int do_warn = 0;
	int have_seckey = 0;
	char *serialno = NULL;
	PKT_public_key *primary = NULL;
	char pkstrbuf[PUBKEY_STRING_SIZE];

	if (opt.with_colons)
	{
	show_key_with_all_names_colon (ctrl, fp, keyblock);
	return;
	}

	/* the keys */
	for (node = keyblock; node; node = node->next)
	{
	if (node->pkt->pkttype == PKT_PUBLIC_KEY
	\|\| (with_subkeys && node->pkt->pkttype == PKT_PUBLIC_SUBKEY
	&& !is_deleted_kbnode (node)))
	{
	PKT_public_key *pk = node->pkt->pkt.public_key;
	const char *otrust = "err";
	const char *trust = "err";

	if (node->pkt->pkttype == PKT_PUBLIC_KEY)
	{
	/* do it here, so that debug messages don't clutter the
	* output */
	static int did_warn = 0;

	trust = get_validity_string (ctrl, pk, NULL);
	otrust = get_ownertrust_string (ctrl, pk, 0);

	/* Show a warning once */
	if (!did_warn
	&& (get_validity (ctrl, keyblock, pk, NULL, NULL, 0)
	& TRUST_FLAG_PENDING_CHECK))
	{
	did_warn = 1;
	do_warn = 1;
	}

	primary = pk;
	}

	if (pk->flags.revoked)
	{
	char *user = get_user_id_string_native (ctrl, pk->revoked.keyid);
	tty_fprintf (fp,
	_("The following key was revoked on"
	" %s by %s key %s\n"),
	revokestr_from_pk (pk),
	gcry_pk_algo_name (pk->revoked.algo), user);
	xfree (user);
	}

	if (with_revoker)
	{
	if (!pk->revkey && pk->numrevkeys)
	BUG ();
	else
	for (i = 0; i < pk->numrevkeys; i++)
	{
	u32 r_keyid[2];
	char *user;
	const char *algo;

	algo = gcry_pk_algo_name (pk->revkey[i].algid);
	keyid_from_fingerprint (ctrl, pk->revkey[i].fpr,
	MAX_FINGERPRINT_LEN, r_keyid);

	user = get_user_id_string_native (ctrl, r_keyid);
	tty_fprintf (fp,
	_("This key may be revoked by %s key %s"),
	algo ? algo : "?", user);

	if (pk->revkey[i].class & 0x40)
	{
	tty_fprintf (fp, " ");
	tty_fprintf (fp, _("(sensitive)"));
	}

	tty_fprintf (fp, "\n");
	xfree (user);
	}
	}

	keyid_from_pk (pk, NULL);

	xfree (serialno);
	serialno = NULL;
	{
	char *hexgrip;

	err = hexkeygrip_from_pk (pk, &hexgrip);
	if (err)
	{
	log_error ("error computing a keygrip: %s\n",
	gpg_strerror (err));
	have_seckey = 0;
	}
	else
	have_seckey = !agent_get_keyinfo (ctrl, hexgrip, &serialno, NULL);
	xfree (hexgrip);
	}

	tty_fprintf
	(fp, "%s%c %s/%s",
	node->pkt->pkttype == PKT_PUBLIC_KEY && have_seckey? "sec" :
	node->pkt->pkttype == PKT_PUBLIC_KEY ? "pub" :
	have_seckey ? "ssb" :
	"sub",
	(node->flag & NODFLG_SELKEY) ? '*' : ' ',
	pubkey_string (pk, pkstrbuf, sizeof pkstrbuf),
	keystr (pk->keyid));

	if (opt.legacy_list_mode)
	tty_fprintf (fp, " ");
	else
	tty_fprintf (fp, "\n ");

	tty_fprintf (fp, _("created: %s"), datestr_from_pk (pk));
	tty_fprintf (fp, " ");
	if (pk->flags.revoked)
	tty_fprintf (fp, _("revoked: %s"), revokestr_from_pk (pk));
	else if (pk->has_expired)
	tty_fprintf (fp, _("expired: %s"), expirestr_from_pk (pk));
	else
	tty_fprintf (fp, _("expires: %s"), expirestr_from_pk (pk));
	tty_fprintf (fp, " ");
	tty_fprintf (fp, _("usage: %s"), usagestr_from_pk (pk, 1));
	tty_fprintf (fp, "\n");

	if (serialno)
	{
	/* The agent told us that a secret key is available and
	that it has been stored on a card. */
	tty_fprintf (fp, "%*s%s", opt.legacy_list_mode? 21:5, "",
	_("card-no: "));
	if (strlen (serialno) == 32
	&& !strncmp (serialno, "D27600012401", 12))
	{
	/* This is an OpenPGP card. Print the relevant part. */
	/* Example: D2760001240101010001000003470000 */
	/* xxxxyyyyyyyy */
	tty_fprintf (fp, "%.s %.s\n",
	4, serialno+16, 8, serialno+20);
	}
	else
	tty_fprintf (fp, "%s\n", serialno);

	}
	else if (pk->seckey_info
	&& pk->seckey_info->is_protected
	&& pk->seckey_info->s2k.mode == 1002)
	{
	/* FIXME: Check whether this code path is still used. */
	tty_fprintf (fp, "%*s%s", opt.legacy_list_mode? 21:5, "",
	_("card-no: "));
	if (pk->seckey_info->ivlen == 16
	&& !memcmp (pk->seckey_info->iv,
	"\xD2\x76\x00\x01\x24\x01", 6))
	{
	/* This is an OpenPGP card. */
	for (i = 8; i < 14; i++)
	{
	if (i == 10)
	tty_fprintf (fp, " ");
	tty_fprintf (fp, "%02X", pk->seckey_info->iv[i]);
	}
	}
	else
	{
	/* Unknown card: Print all. */
	for (i = 0; i < pk->seckey_info->ivlen; i++)
	tty_fprintf (fp, "%02X", pk->seckey_info->iv[i]);
	}
	tty_fprintf (fp, "\n");
	}

	if (node->pkt->pkttype == PKT_PUBLIC_KEY
	\|\| node->pkt->pkttype == PKT_SECRET_KEY)
	{
	if (opt.trust_model != TM_ALWAYS)
	{
	tty_fprintf (fp, "%*s",
	opt.legacy_list_mode?
	((int) keystrlen () + 13):5, "");
	/* Ownertrust is only meaningful for the PGP or
	classic trust models, or PGP combined with TOFU */
	if (opt.trust_model == TM_PGP
	\|\| opt.trust_model == TM_CLASSIC
	\|\| opt.trust_model == TM_TOFU_PGP)
	{
	int width = 14 - strlen (otrust);
	if (width <= 0)
	width = 1;
	tty_fprintf (fp, _("trust: %s"), otrust);
	tty_fprintf (fp, "%*s", width, "");
	}

	tty_fprintf (fp, _("validity: %s"), trust);
	tty_fprintf (fp, "\n");
	}
	if (node->pkt->pkttype == PKT_PUBLIC_KEY
	&& (get_ownertrust (ctrl, pk) & TRUST_FLAG_DISABLED))
	{
	tty_fprintf (fp, "*** ");
	tty_fprintf (fp, _("This key has been disabled"));
	tty_fprintf (fp, "\n");
	}
	}

	if ((node->pkt->pkttype == PKT_PUBLIC_KEY
	\|\| node->pkt->pkttype == PKT_SECRET_KEY) && with_fpr)
	{
	print_fingerprint (ctrl, fp, pk, 2);
	tty_fprintf (fp, "\n");
	}
	}
	}

	show_names (ctrl, fp,
	keyblock, primary, only_marked ? NODFLG_MARK_A : 0, with_prefs);

	if (do_warn && !nowarn)
	tty_fprintf (fp, _("Please note that the shown key validity"
	" is not necessarily correct\n"
	"unless you restart the program.\n"));

	xfree (serialno);
	}


	/* Display basic key information. This function is suitable to show
	* information on the key without any dependencies on the trustdb or
	* any other internal GnuPG stuff. KEYBLOCK may either be a public or
	* a secret key. This function may be called with KEYBLOCK containing
	* secret keys and thus the printing of "pub" vs. "sec" does only
	* depend on the packet type and not by checking with gpg-agent. If
	* PRINT_SEC ist set "sec" is printed instead of "pub". */
	void
	show_basic_key_info (ctrl_t ctrl, kbnode_t keyblock, int print_sec)
	{
	KBNODE node;
	int i;
	char pkstrbuf[PUBKEY_STRING_SIZE];

	/* The primary key */
	for (node = keyblock; node; node = node->next)
	{
	if (node->pkt->pkttype == PKT_PUBLIC_KEY
	\|\| node->pkt->pkttype == PKT_SECRET_KEY)
	{
	PKT_public_key *pk = node->pkt->pkt.public_key;
	const char *tag;

	if (node->pkt->pkttype == PKT_SECRET_KEY \|\| print_sec)
	tag = "sec";
	else
	tag = "pub";

	/* Note, we use the same format string as in other show
	functions to make the translation job easier. */
	tty_printf ("%s %s/%s ",
	tag,
	pubkey_string (pk, pkstrbuf, sizeof pkstrbuf),
	keystr_from_pk (pk));
	tty_printf (_("created: %s"), datestr_from_pk (pk));
	tty_printf (" ");
	tty_printf (_("expires: %s"), expirestr_from_pk (pk));
	tty_printf ("\n");
	print_fingerprint (ctrl, NULL, pk, 3);
	tty_printf ("\n");
	}
	}

	/* The user IDs. */
	for (i = 0, node = keyblock; node; node = node->next)
	{
	if (node->pkt->pkttype == PKT_USER_ID)
	{
	PKT_user_id *uid = node->pkt->pkt.user_id;
	++i;

	tty_printf (" ");
	if (uid->flags.revoked)
	tty_printf ("[%s] ", _("revoked"));
	else if (uid->flags.expired)
	tty_printf ("[%s] ", _("expired"));
	tty_print_utf8_string (uid->name, uid->len);
	tty_printf ("\n");
	}
	}
	}


	static void
	show_key_and_fingerprint (ctrl_t ctrl, kbnode_t keyblock, int with_subkeys)
	{
	kbnode_t node;
	PKT_public_key *pk = NULL;
	char pkstrbuf[PUBKEY_STRING_SIZE];

	for (node = keyblock; node; node = node->next)
	{
	if (node->pkt->pkttype == PKT_PUBLIC_KEY)
	{
	pk = node->pkt->pkt.public_key;
	tty_printf ("pub %s/%s %s ",
	pubkey_string (pk, pkstrbuf, sizeof pkstrbuf),
	keystr_from_pk(pk),
	datestr_from_pk (pk));
	}
	else if (node->pkt->pkttype == PKT_USER_ID)
	{
	PKT_user_id *uid = node->pkt->pkt.user_id;
	tty_print_utf8_string (uid->name, uid->len);
	break;
	}
	}
	tty_printf ("\n");
	if (pk)
	print_fingerprint (ctrl, NULL, pk, 2);
	if (with_subkeys)
	{
	for (node = keyblock; node; node = node->next)
	{
	if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
	{
	pk = node->pkt->pkt.public_key;
	tty_printf ("sub %s/%s %s [%s]\n",
	pubkey_string (pk, pkstrbuf, sizeof pkstrbuf),
	keystr_from_pk(pk),
	datestr_from_pk (pk),
	usagestr_from_pk (pk, 0));

	print_fingerprint (ctrl, NULL, pk, 4);
	}
	}
	}
	}


	/* Show a listing of the primary and its subkeys along with their
	keygrips. */
	static void
	show_key_and_grip (kbnode_t keyblock)
	{
	kbnode_t node;
	PKT_public_key *pk = NULL;
	char pkstrbuf[PUBKEY_STRING_SIZE];
	char *hexgrip;

	for (node = keyblock; node; node = node->next)
	{
	if (node->pkt->pkttype == PKT_PUBLIC_KEY
	\|\| node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
	{
	pk = node->pkt->pkt.public_key;
	tty_printf ("%s %s/%s %s [%s]\n",
	node->pkt->pkttype == PKT_PUBLIC_KEY? "pub":"sub",
	pubkey_string (pk, pkstrbuf, sizeof pkstrbuf),
	keystr_from_pk(pk),
	datestr_from_pk (pk),
	usagestr_from_pk (pk, 0));

	if (!hexkeygrip_from_pk (pk, &hexgrip))
	{
	tty_printf (" Keygrip: %s\n", hexgrip);
	xfree (hexgrip);
	}
	}
	}
	}


	/* Show a warning if no uids on the key have the primary uid flag
	set. */
	static void
	no_primary_warning (KBNODE keyblock)
	{
	KBNODE node;
	int have_primary = 0, uid_count = 0;

	/* TODO: if we ever start behaving differently with a primary or
	non-primary attribute ID, we will need to check for attributes
	here as well. */

	for (node = keyblock; node; node = node->next)
	{
	if (node->pkt->pkttype == PKT_USER_ID
	&& node->pkt->pkt.user_id->attrib_data == NULL)
	{
	uid_count++;

	if (node->pkt->pkt.user_id->flags.primary == 2)
	{
	have_primary = 1;
	break;
	}
	}
	}

	if (uid_count > 1 && !have_primary)
	log_info (_
	("WARNING: no user ID has been marked as primary. This command"
	" may\n cause a different user ID to become"
	" the assumed primary.\n"));
	}


	/* Print a warning if the latest encryption subkey expires soon. This
	function is called after the expire data of the primary key has
	been changed. */
	static void
	subkey_expire_warning (kbnode_t keyblock)
	{
	u32 curtime = make_timestamp ();
	kbnode_t node;
	PKT_public_key *pk;
	/* u32 mainexpire = 0; */
	u32 subexpire = 0;
	u32 latest_date = 0;

	for (node = keyblock; node; node = node->next)
	{
	/* if (node->pkt->pkttype == PKT_PUBLIC_KEY) */
	/* { */
	/* pk = node->pkt->pkt.public_key; */
	/* mainexpire = pk->expiredate; */
	/* } */

	if (node->pkt->pkttype != PKT_PUBLIC_SUBKEY)
	continue;
	pk = node->pkt->pkt.public_key;

	if (!pk->flags.valid)
	continue;
	if (pk->flags.revoked)
	continue;
	if (pk->timestamp > curtime)
	continue; /* Ignore future keys. */
	if (!(pk->pubkey_usage & PUBKEY_USAGE_ENC))
	continue; /* Not an encryption key. */

	if (pk->timestamp > latest_date \|\| (!pk->timestamp && !latest_date))
	{
	latest_date = pk->timestamp;
	subexpire = pk->expiredate;
	}
	}

	if (!subexpire)
	return; /* No valid subkey with an expiration time. */

	if (curtime + (10*86400) > subexpire)
	{
	log_info (_("WARNING: Your encryption subkey expires soon.\n"));
	log_info (_("You may want to change its expiration date too.\n"));
	}
	}


	/*
	* Ask for a new user id, add the self-signature, and update the
	* keyblock. If UIDSTRING is not NULL the user ID is generated
	* unattended using that string. UIDSTRING is expected to be utf-8
	* encoded and white space trimmed. Returns true if there is a new
	* user id.
	*/
	static int
	menu_adduid (ctrl_t ctrl, kbnode_t pub_keyblock,
	int photo, const char photo_name, const char uidstring)
	{
	PKT_user_id *uid;
	PKT_public_key *pk = NULL;
	PKT_signature *sig = NULL;
	PACKET *pkt;
	KBNODE node;
	KBNODE pub_where = NULL;
	gpg_error_t err;

	if (photo && uidstring)
	return 0; /* Not allowed. */

	for (node = pub_keyblock; node; pub_where = node, node = node->next)
	{
	if (node->pkt->pkttype == PKT_PUBLIC_KEY)
	pk = node->pkt->pkt.public_key;
	else if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
	break;
	}
	if (!node) /* No subkey. */
	pub_where = NULL;
	log_assert (pk);

	if (photo)
	{
	int hasattrib = 0;

	for (node = pub_keyblock; node; node = node->next)
	if (node->pkt->pkttype == PKT_USER_ID &&
	node->pkt->pkt.user_id->attrib_data != NULL)
	{
	hasattrib = 1;
	break;
	}

	/* It is legal but bad for compatibility to add a photo ID to a
	v3 key as it means that PGP2 will not be able to use that key
	anymore. Also, PGP may not expect a photo on a v3 key.
	Don't bother to ask this if the key already has a photo - any
	damage has already been done at that point. -dms */
	if (pk->version == 3 && !hasattrib)
	{
	if (opt.expert)
	{
	tty_printf (_("WARNING: This is a PGP2-style key. "
	"Adding a photo ID may cause some versions\n"
	" of PGP to reject this key.\n"));

	if (!cpr_get_answer_is_yes ("keyedit.v3_photo.okay",
	_("Are you sure you still want "
	"to add it? (y/N) ")))
	return 0;
	}
	else
	{
	tty_printf (_("You may not add a photo ID to "
	"a PGP2-style key.\n"));
	return 0;
	}
	}

	uid = generate_photo_id (ctrl, pk, photo_name);
	}
	else
	uid = generate_user_id (pub_keyblock, uidstring);
	if (!uid)
	{
	if (uidstring)
	{
	write_status_error ("adduid", gpg_error (304));
	log_error ("%s", _("Such a user ID already exists on this key!\n"));
	}
	return 0;
	}

	err = make_keysig_packet (ctrl, &sig, pk, uid, NULL, pk, 0x13, 0, 0, 0,
	keygen_add_std_prefs, pk, NULL);
	if (err)
	{
	write_status_error ("keysig", err);
	log_error ("signing failed: %s\n", gpg_strerror (err));
	free_user_id (uid);
	return 0;
	}

	/* Insert/append to public keyblock */
	pkt = xmalloc_clear (sizeof *pkt);
	pkt->pkttype = PKT_USER_ID;
	pkt->pkt.user_id = uid;
	node = new_kbnode (pkt);
	if (pub_where)
	insert_kbnode (pub_where, node, 0);
	else
	add_kbnode (pub_keyblock, node);
	pkt = xmalloc_clear (sizeof *pkt);
	pkt->pkttype = PKT_SIGNATURE;
	pkt->pkt.signature = sig;
	if (pub_where)
	insert_kbnode (node, new_kbnode (pkt), 0);
	else
	add_kbnode (pub_keyblock, new_kbnode (pkt));
	return 1;
	}


	/*
	* Remove all selected userids from the keyring
	*/
	static void
	menu_deluid (KBNODE pub_keyblock)
	{
	KBNODE node;
	int selected = 0;

	for (node = pub_keyblock; node; node = node->next)
	{
	if (node->pkt->pkttype == PKT_USER_ID)
	{
	selected = node->flag & NODFLG_SELUID;
	if (selected)
	{
	/* Only cause a trust update if we delete a
	non-revoked user id */
	if (!node->pkt->pkt.user_id->flags.revoked)
	update_trust = 1;
	delete_kbnode (node);
	}
	}
	else if (selected && node->pkt->pkttype == PKT_SIGNATURE)
	delete_kbnode (node);
	else if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
	selected = 0;
	}
	commit_kbnode (&pub_keyblock);
	}


	static int
	menu_delsig (ctrl_t ctrl, kbnode_t pub_keyblock)
	{
	KBNODE node;
	PKT_user_id *uid = NULL;
	int changed = 0;

	for (node = pub_keyblock; node; node = node->next)
	{
	if (node->pkt->pkttype == PKT_USER_ID)
	{
	uid = (node->flag & NODFLG_SELUID) ? node->pkt->pkt.user_id : NULL;
	}
	else if (uid && node->pkt->pkttype == PKT_SIGNATURE)
	{
	int okay, valid, selfsig, inv_sig, no_key, other_err;

	tty_printf ("uid ");
	tty_print_utf8_string (uid->name, uid->len);
	tty_printf ("\n");

	okay = inv_sig = no_key = other_err = 0;
	if (opt.with_colons)
	valid = print_and_check_one_sig_colon (ctrl, pub_keyblock, node,
	&inv_sig, &no_key,
	&other_err, &selfsig, 1);
	else
	valid = print_and_check_one_sig (ctrl, pub_keyblock, node,
	&inv_sig, &no_key, &other_err,
	&selfsig, 1, 0);

	if (valid)
	{
	okay = cpr_get_answer_yes_no_quit
	("keyedit.delsig.valid",
	_("Delete this good signature? (y/N/q)"));

	/* Only update trust if we delete a good signature.
	The other two cases do not affect trust. */
	if (okay)
	update_trust = 1;
	}
	else if (inv_sig \|\| other_err)
	okay = cpr_get_answer_yes_no_quit
	("keyedit.delsig.invalid",
	_("Delete this invalid signature? (y/N/q)"));
	else if (no_key)
	okay = cpr_get_answer_yes_no_quit
	("keyedit.delsig.unknown",
	_("Delete this unknown signature? (y/N/q)"));

	if (okay == -1)
	break;
	if (okay && selfsig
	&& !cpr_get_answer_is_yes
	("keyedit.delsig.selfsig",
	_("Really delete this self-signature? (y/N)")))
	okay = 0;
	if (okay)
	{
	delete_kbnode (node);
	changed++;
	}

	}
	else if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
	uid = NULL;
	}

	if (changed)
	{
	commit_kbnode (&pub_keyblock);
	tty_printf (ngettext("Deleted %d signature.\n",
	"Deleted %d signatures.\n", changed), changed);
	}
	else
	tty_printf (_("Nothing deleted.\n"));

	return changed;
	}


	static int
	menu_clean (ctrl_t ctrl, kbnode_t keyblock, int self_only)
	{
	KBNODE uidnode;
	int modified = 0, select_all = !count_selected_uids (keyblock);

	for (uidnode = keyblock->next;
	uidnode && uidnode->pkt->pkttype != PKT_PUBLIC_SUBKEY;
	uidnode = uidnode->next)
	{
	if (uidnode->pkt->pkttype == PKT_USER_ID
	&& (uidnode->flag & NODFLG_SELUID \|\| select_all))
	{
	int uids = 0, sigs = 0;
	char *user = utf8_to_native (uidnode->pkt->pkt.user_id->name,
	uidnode->pkt->pkt.user_id->len,
	0);

	clean_one_uid (ctrl, keyblock, uidnode, opt.verbose, self_only, &uids,
	&sigs);
	if (uids)
	{
	const char *reason;

	if (uidnode->pkt->pkt.user_id->flags.revoked)
	reason = _("revoked");
	else if (uidnode->pkt->pkt.user_id->flags.expired)
	reason = _("expired");
	else
	reason = _("invalid");

	tty_printf (_("User ID \"%s\" compacted: %s\n"), user, reason);

	modified = 1;
	}
	else if (sigs)
	{
	tty_printf (ngettext("User ID \"%s\": %d signature removed\n",
	"User ID \"%s\": %d signatures removed\n",
	sigs), user, sigs);
	modified = 1;
	}
	else
	{
	tty_printf (self_only == 1 ?
	_("User ID \"%s\": already minimized\n") :
	_("User ID \"%s\": already clean\n"), user);
	}

	xfree (user);
	}
	}

	return modified;
	}


	/*
	* Remove some of the secondary keys
	*/
	static void
	menu_delkey (KBNODE pub_keyblock)
	{
	KBNODE node;
	int selected = 0;

	for (node = pub_keyblock; node; node = node->next)
	{
	if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
	{
	selected = node->flag & NODFLG_SELKEY;
	if (selected)
	delete_kbnode (node);
	}
	else if (selected && node->pkt->pkttype == PKT_SIGNATURE)
	delete_kbnode (node);
	else
	selected = 0;
	}
	commit_kbnode (&pub_keyblock);

	/* No need to set update_trust here since signing keys are no
	longer used to certify other keys, so there is no change in
	trust when revoking/removing them. */
	}


	/*
	* Ask for a new revoker, create the self-signature and put it into
	* the keyblock. Returns true if there is a new revoker.
	*/
	static int
	menu_addrevoker (ctrl_t ctrl, kbnode_t pub_keyblock, int sensitive)
	{
	PKT_public_key *pk = NULL;
	PKT_public_key *revoker_pk = NULL;
	PKT_signature *sig = NULL;
	PACKET *pkt;
	struct revocation_key revkey;
	size_t fprlen;
	int rc;

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

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

	if (pk->numrevkeys == 0 && pk->version == 3)
	{
	/* It is legal but bad for compatibility to add a revoker to a
	v3 key as it means that PGP2 will not be able to use that key
	anymore. Also, PGP may not expect a revoker on a v3 key.
	Don't bother to ask this if the key already has a revoker -
	any damage has already been done at that point. -dms */
	if (opt.expert)
	{
	tty_printf (_("WARNING: This is a PGP 2.x-style key. "
	"Adding a designated revoker may cause\n"
	" some versions of PGP to reject this key.\n"));

	if (!cpr_get_answer_is_yes ("keyedit.v3_revoker.okay",
	_("Are you sure you still want "
	"to add it? (y/N) ")))
	return 0;
	}
	else
	{
	tty_printf (_("You may not add a designated revoker to "
	"a PGP 2.x-style key.\n"));
	return 0;
	}
	}

	for (;;)
	{
	char *answer;

	free_public_key (revoker_pk);
	revoker_pk = xmalloc_clear (sizeof (*revoker_pk));

	tty_printf ("\n");

	answer = cpr_get_utf8
	("keyedit.add_revoker",
	_("Enter the user ID of the designated revoker: "));
	if (answer[0] == '\0' \|\| answer[0] == CONTROL_D)
	{
	xfree (answer);
	goto fail;
	}

	/* Note that I'm requesting CERT here, which usually implies
	primary keys only, but some casual testing shows that PGP and
	GnuPG both can handle a designated revocation from a subkey. */
	revoker_pk->req_usage = PUBKEY_USAGE_CERT;
	rc = get_pubkey_byname (ctrl, GET_PUBKEY_NO_AKL,
	NULL, revoker_pk, answer, NULL, NULL, 1);
	if (rc)
	{
	log_error (_("key \"%s\" not found: %s\n"), answer,
	gpg_strerror (rc));
	xfree (answer);
	continue;
	}

	xfree (answer);

	fingerprint_from_pk (revoker_pk, revkey.fpr, &fprlen);
	if (fprlen != 20)
	{
	log_error (_("cannot appoint a PGP 2.x style key as a "
	"designated revoker\n"));
	continue;
	}

	revkey.class = 0x80;
	if (sensitive)
	revkey.class \|= 0x40;
	revkey.algid = revoker_pk->pubkey_algo;

	if (cmp_public_keys (revoker_pk, pk) == 0)
	{
	/* This actually causes no harm (after all, a key that
	designates itself as a revoker is the same as a
	regular key), but it's easy enough to check. */
	log_error (_("you cannot appoint a key as its own "
	"designated revoker\n"));

	continue;
	}

	keyid_from_pk (pk, NULL);

	/* Does this revkey already exist? */
	if (!pk->revkey && pk->numrevkeys)
	BUG ();
	else
	{
	int i;

	for (i = 0; i < pk->numrevkeys; i++)
	{
	if (memcmp (&pk->revkey[i], &revkey,
	sizeof (struct revocation_key)) == 0)
	{
	char buf[50];

	log_error (_("this key has already been designated "
	"as a revoker\n"));

	format_keyid (pk_keyid (pk), KF_LONG, buf, sizeof (buf));
	write_status_text (STATUS_ALREADY_SIGNED, buf);

	break;
	}
	}

	if (i < pk->numrevkeys)
	continue;
	}

	print_pubkey_info (ctrl, NULL, revoker_pk);
	print_fingerprint (ctrl, NULL, revoker_pk, 2);
	tty_printf ("\n");

	tty_printf (_("WARNING: appointing a key as a designated revoker "
	"cannot be undone!\n"));

	tty_printf ("\n");

	if (!cpr_get_answer_is_yes ("keyedit.add_revoker.okay",
	_("Are you sure you want to appoint this "
	"key as a designated revoker? (y/N) ")))
	continue;

	free_public_key (revoker_pk);
	revoker_pk = NULL;
	break;
	}

	rc = make_keysig_packet (ctrl, &sig, pk, NULL, NULL, pk, 0x1F, 0, 0, 0,
	keygen_add_revkey, &revkey, NULL);
	if (rc)
	{
	write_status_error ("keysig", rc);
	log_error ("signing failed: %s\n", gpg_strerror (rc));
	goto fail;
	}

	/* Insert into public keyblock. */
	pkt = xmalloc_clear (sizeof *pkt);
	pkt->pkttype = PKT_SIGNATURE;
	pkt->pkt.signature = sig;
	insert_kbnode (pub_keyblock, new_kbnode (pkt), PKT_SIGNATURE);

	return 1;

	fail:
	if (sig)
	free_seckey_enc (sig);
	free_public_key (revoker_pk);

	return 0;
	}


	/* With FORCE_MAINKEY cleared this function handles the interactive
	* menu option "expire". With UNATTENDED set to 1 this function only
	* sets the expiration date of the primary key to NEWEXPIRATION and
	* avoid all interactivity; with a value of 2 only the flagged subkeys
	* are set to NEWEXPIRATION. Returns 0 if nothing was done,
	* GPG_ERR_TRUE if the key was modified, or any other error code. */
	static gpg_error_t
	menu_expire (ctrl_t ctrl, kbnode_t pub_keyblock,
	int unattended, u32 newexpiration)
	{
	int signumber, rc;
	u32 expiredate;
	int only_mainkey; /* Set if only the mainkey is to be updated. */
	PKT_public_key main_pk, sub_pk;
	PKT_user_id *uid;
	kbnode_t node;
	u32 keyid[2];

	if (unattended)
	{
	only_mainkey = (unattended == 1);
	expiredate = newexpiration;
	}
	else
	{
	int n1;

	only_mainkey = 0;
	n1 = count_selected_keys (pub_keyblock);
	if (n1 > 1)
	{
	if (!cpr_get_answer_is_yes
	("keyedit.expire_multiple_subkeys.okay",
	_("Are you sure you want to change the"
	" expiration time for multiple subkeys? (y/N) ")))
	return gpg_error (GPG_ERR_CANCELED);;
	}
	else if (n1)
	tty_printf (_("Changing expiration time for a subkey.\n"));
	else
	{
	tty_printf (_("Changing expiration time for the primary key.\n"));
	only_mainkey = 1;
	no_primary_warning (pub_keyblock);
	}

	expiredate = ask_expiredate ();
	}


	/* Now we can actually change the self-signature(s) */
	main_pk = sub_pk = NULL;
	uid = NULL;
	signumber = 0;
	for (node = pub_keyblock; node; node = node->next)
	{
	if (node->pkt->pkttype == PKT_PUBLIC_KEY)
	{
	main_pk = node->pkt->pkt.public_key;
	keyid_from_pk (main_pk, keyid);
	main_pk->expiredate = expiredate;
	}
	else if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
	{
	if ((node->flag & NODFLG_SELKEY) && unattended != 1)
	{
	/* The flag is set and we do not want to set the
	* expiration date only for the main key. */
	sub_pk = node->pkt->pkt.public_key;
	sub_pk->expiredate = expiredate;
	}
	else
	sub_pk = NULL;
	}
	else if (node->pkt->pkttype == PKT_USER_ID)
	uid = node->pkt->pkt.user_id;
	else if (main_pk && node->pkt->pkttype == PKT_SIGNATURE
	&& (only_mainkey \|\| sub_pk))
	{
	PKT_signature *sig = node->pkt->pkt.signature;

	if (keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1]
	&& ((only_mainkey && uid
	&& uid->created && (sig->sig_class & ~3) == 0x10)
	\|\| (!only_mainkey && sig->sig_class == 0x18))
	&& sig->flags.chosen_selfsig)
	{
	/* This is a self-signature which is to be replaced. */
	PKT_signature *newsig;
	PACKET *newpkt;

	signumber++;

	if ((only_mainkey && main_pk->version < 4)
	\|\| (!only_mainkey && sub_pk->version < 4))
	{
	log_info
	(_("You can't change the expiration date of a v3 key\n"));
	return gpg_error (GPG_ERR_LEGACY_KEY);
	}

	if (only_mainkey)
	rc = update_keysig_packet (ctrl,
	&newsig, sig, main_pk, uid, NULL,
	main_pk, keygen_add_key_expire,
	main_pk);
	else
	rc =
	update_keysig_packet (ctrl,
	&newsig, sig, main_pk, NULL, sub_pk,
	main_pk, keygen_add_key_expire, sub_pk);
	if (rc)
	{
	log_error ("make_keysig_packet failed: %s\n",
	gpg_strerror (rc));
	if (gpg_err_code (rc) == GPG_ERR_TRUE)
	rc = GPG_ERR_GENERAL;
	return rc;
	}

	/* Replace the packet. */
	newpkt = xmalloc_clear (sizeof *newpkt);
	newpkt->pkttype = PKT_SIGNATURE;
	newpkt->pkt.signature = newsig;
	free_packet (node->pkt, NULL);
	xfree (node->pkt);
	node->pkt = newpkt;
	sub_pk = NULL;
	}
	}
	}

	update_trust = 1;
	return gpg_error (GPG_ERR_TRUE);
	}


	/* Change the capability of a selected key. This command should only
	* be used to rectify badly created keys and as such is not suggested
	* for general use. */
	static int
	menu_changeusage (ctrl_t ctrl, kbnode_t keyblock)
	{
	int n1, rc;
	int mainkey = 0;
	PKT_public_key main_pk, sub_pk;
	PKT_user_id *uid;
	kbnode_t node;
	u32 keyid[2];

	n1 = count_selected_keys (keyblock);
	if (n1 > 1)
	{
	tty_printf (_("You must select exactly one key.\n"));
	return 0;
	}
	else if (n1)
	tty_printf (_("Changing usage of a subkey.\n"));
	else
	{
	tty_printf (_("Changing usage of the primary key.\n"));
	mainkey = 1;
	}

	/* Now we can actually change the self-signature(s) */
	main_pk = sub_pk = NULL;
	uid = NULL;
	for (node = keyblock; node; node = node->next)
	{
	if (node->pkt->pkttype == PKT_PUBLIC_KEY)
	{
	main_pk = node->pkt->pkt.public_key;
	keyid_from_pk (main_pk, keyid);
	}
	else if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
	{
	if (node->flag & NODFLG_SELKEY)
	sub_pk = node->pkt->pkt.public_key;
	else
	sub_pk = NULL;
	}
	else if (node->pkt->pkttype == PKT_USER_ID)
	uid = node->pkt->pkt.user_id;
	else if (main_pk && node->pkt->pkttype == PKT_SIGNATURE
	&& (mainkey \|\| sub_pk))
	{
	PKT_signature *sig = node->pkt->pkt.signature;
	if (keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1]
	&& ((mainkey && uid
	&& uid->created && (sig->sig_class & ~3) == 0x10)
	\|\| (!mainkey && sig->sig_class == 0x18))
	&& sig->flags.chosen_selfsig)
	{
	/* This is the self-signature which is to be replaced. */
	PKT_signature *newsig;
	PACKET *newpkt;

	if ((mainkey && main_pk->version < 4)
	\|\| (!mainkey && sub_pk->version < 4))
	{
	/* Note: This won't happen because we don't support
	* v3 keys anymore. */
	log_info ("You can't change the capabilities of a v3 key\n");
	return 0;
	}

	if (mainkey)
	main_pk->pubkey_usage = ask_key_flags (main_pk->pubkey_algo, 0,
	main_pk->pubkey_usage);
	else
	sub_pk->pubkey_usage = ask_key_flags (sub_pk->pubkey_algo, 1,
	sub_pk->pubkey_usage);

	if (mainkey)
	rc = update_keysig_packet (ctrl,
	&newsig, sig, main_pk, uid, NULL,
	main_pk, keygen_add_key_flags,
	main_pk);
	else
	rc =
	update_keysig_packet (ctrl,
	&newsig, sig, main_pk, NULL, sub_pk,
	main_pk, keygen_add_key_flags, sub_pk);
	if (rc)
	{
	log_error ("make_keysig_packet failed: %s\n",
	gpg_strerror (rc));
	return 0;
	}

	/* Replace the packet. */
	newpkt = xmalloc_clear (sizeof *newpkt);
	newpkt->pkttype = PKT_SIGNATURE;
	newpkt->pkt.signature = newsig;
	free_packet (node->pkt, NULL);
	xfree (node->pkt);
	node->pkt = newpkt;
	sub_pk = NULL;
	break;
	}
	}
	}

	return 1;
	}


	static int
	menu_backsign (ctrl_t ctrl, kbnode_t pub_keyblock)
	{
	int rc, modified = 0;
	PKT_public_key *main_pk;
	KBNODE node;
	u32 timestamp;

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

	merge_keys_and_selfsig (ctrl, pub_keyblock);
	main_pk = pub_keyblock->pkt->pkt.public_key;
	keyid_from_pk (main_pk, NULL);

	/* We use the same timestamp for all backsigs so that we don't
	reveal information about the used machine. */
	timestamp = make_timestamp ();

	for (node = pub_keyblock; node; node = node->next)
	{
	PKT_public_key *sub_pk = NULL;
	KBNODE node2, sig_pk = NULL /,sig_sk = NULL/;
	/* char passphrase; /

	/* Find a signing subkey with no backsig */
	if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
	{
	if (node->pkt->pkt.public_key->pubkey_usage & PUBKEY_USAGE_SIG)
	{
	if (node->pkt->pkt.public_key->flags.backsig)
	tty_printf (_
	("signing subkey %s is already cross-certified\n"),
	keystr_from_pk (node->pkt->pkt.public_key));
	else
	sub_pk = node->pkt->pkt.public_key;
	}
	else
	tty_printf (_("subkey %s does not sign and so does"
	" not need to be cross-certified\n"),
	keystr_from_pk (node->pkt->pkt.public_key));
	}

	if (!sub_pk)
	continue;

	/* Find the selected selfsig on this subkey */
	for (node2 = node->next;
	node2 && node2->pkt->pkttype == PKT_SIGNATURE; node2 = node2->next)
	if (node2->pkt->pkt.signature->version >= 4
	&& node2->pkt->pkt.signature->flags.chosen_selfsig)
	{
	sig_pk = node2;
	break;
	}

	if (!sig_pk)
	continue;

	/* Find the secret subkey that matches the public subkey */
	log_debug ("FIXME: Check whether a secret subkey is available.\n");
	/* if (!sub_sk) */
	/* { */
	/* tty_printf (_("no secret subkey for public subkey %s - ignoring\n"), */
	/* keystr_from_pk (sub_pk)); */
	/* continue; */
	/* } */


	/* Now we can get to work. */

	rc = make_backsig (ctrl,
	sig_pk->pkt->pkt.signature, main_pk, sub_pk, sub_pk,
	timestamp, NULL);
	if (!rc)
	{
	PKT_signature *newsig;
	PACKET *newpkt;

	rc = update_keysig_packet (ctrl,
	&newsig, sig_pk->pkt->pkt.signature,
	main_pk, NULL, sub_pk, main_pk,
	NULL, NULL);
	if (!rc)
	{
	/* Put the new sig into place on the pubkey */
	newpkt = xmalloc_clear (sizeof (*newpkt));
	newpkt->pkttype = PKT_SIGNATURE;
	newpkt->pkt.signature = newsig;
	free_packet (sig_pk->pkt, NULL);
	xfree (sig_pk->pkt);
	sig_pk->pkt = newpkt;

	modified = 1;
	}
	else
	{
	log_error ("update_keysig_packet failed: %s\n",
	gpg_strerror (rc));
	break;
	}
	}
	else
	{
	log_error ("make_backsig failed: %s\n", gpg_strerror (rc));
	break;
	}
	}

	return modified;
	}


	static int
	change_primary_uid_cb (PKT_signature * sig, void *opaque)
	{
	byte buf[1];

	/* first clear all primary uid flags so that we are sure none are
	* lingering around */
	delete_sig_subpkt (sig->hashed, SIGSUBPKT_PRIMARY_UID);
	delete_sig_subpkt (sig->unhashed, SIGSUBPKT_PRIMARY_UID);

	/* if opaque is set,we want to set the primary id */
	if (opaque)
	{
	buf[0] = 1;
	build_sig_subpkt (sig, SIGSUBPKT_PRIMARY_UID, buf, 1);
	}

	return 0;
	}


	/*
	* Set the primary uid flag for the selected UID. We will also reset
	* all other primary uid flags. For this to work we have to update
	* all the signature timestamps. If we would do this with the current
	* time, we lose quite a lot of information, so we use a kludge to
	* do this: Just increment the timestamp by one second which is
	* sufficient to updated a signature during import.
	*/
	static int
	menu_set_primary_uid (ctrl_t ctrl, kbnode_t pub_keyblock)
	{
	PKT_public_key *main_pk;
	PKT_user_id *uid;
	KBNODE node;
	u32 keyid[2];
	int selected;
	int attribute = 0;
	int modified = 0;

	if (count_selected_uids (pub_keyblock) != 1)
	{
	tty_printf (_("Please select exactly one user ID.\n"));
	return 0;
	}

	main_pk = NULL;
	uid = NULL;
	selected = 0;

	/* Is our selected uid an attribute packet? */
	for (node = pub_keyblock; node; node = node->next)
	if (node->pkt->pkttype == PKT_USER_ID && node->flag & NODFLG_SELUID)
	attribute = (node->pkt->pkt.user_id->attrib_data != NULL);

	for (node = pub_keyblock; node; node = node->next)
	{
	if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
	break; /* No more user ids expected - ready. */

	if (node->pkt->pkttype == PKT_PUBLIC_KEY)
	{
	main_pk = node->pkt->pkt.public_key;
	keyid_from_pk (main_pk, keyid);
	}
	else if (node->pkt->pkttype == PKT_USER_ID)
	{
	uid = node->pkt->pkt.user_id;
	selected = node->flag & NODFLG_SELUID;
	}
	else if (main_pk && uid && node->pkt->pkttype == PKT_SIGNATURE)
	{
	PKT_signature *sig = node->pkt->pkt.signature;
	if (keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1]
	&& (uid && (sig->sig_class & ~3) == 0x10)
	&& attribute == (uid->attrib_data != NULL)
	&& sig->flags.chosen_selfsig)
	{
	if (sig->version < 4)
	{
	char *user =
	utf8_to_native (uid->name, strlen (uid->name), 0);

	log_info (_("skipping v3 self-signature on user ID \"%s\"\n"),
	user);
	xfree (user);
	}
	else
	{
	/* This is a selfsignature which is to be replaced.
	We can just ignore v3 signatures because they are
	not able to carry the primary ID flag. We also
	ignore self-sigs on user IDs that are not of the
	same type that we are making primary. That is, if
	we are making a user ID primary, we alter user IDs.
	If we are making an attribute packet primary, we
	alter attribute packets. */

	/* FIXME: We must make sure that we only have one
	self-signature per user ID here (not counting
	revocations) */
	PKT_signature *newsig;
	PACKET *newpkt;
	const byte *p;
	int action;

	/* See whether this signature has the primary UID flag. */
	p = parse_sig_subpkt (sig->hashed,
	SIGSUBPKT_PRIMARY_UID, NULL);
	if (!p)
	p = parse_sig_subpkt (sig->unhashed,
	SIGSUBPKT_PRIMARY_UID, NULL);
	if (p && p) / yes */
	action = selected ? 0 : -1;
	else /* no */
	action = selected ? 1 : 0;

	if (action)
	{
	int rc = update_keysig_packet (ctrl, &newsig, sig,
	main_pk, uid, NULL,
	main_pk,
	change_primary_uid_cb,
	action > 0 ? "x" : NULL);
	if (rc)
	{
	log_error ("update_keysig_packet failed: %s\n",
	gpg_strerror (rc));
	return 0;
	}
	/* replace the packet */
	newpkt = xmalloc_clear (sizeof *newpkt);
	newpkt->pkttype = PKT_SIGNATURE;
	newpkt->pkt.signature = newsig;
	free_packet (node->pkt, NULL);
	xfree (node->pkt);
	node->pkt = newpkt;
	modified = 1;
	}
	}
	}
	}
	}

	return modified;
	}


	/*
	* Set preferences to new values for the selected user IDs
	*/
	static int
	menu_set_preferences (ctrl_t ctrl, kbnode_t pub_keyblock)
	{
	PKT_public_key *main_pk;
	PKT_user_id *uid;
	KBNODE node;
	u32 keyid[2];
	int selected, select_all;
	int modified = 0;

	no_primary_warning (pub_keyblock);

	select_all = !count_selected_uids (pub_keyblock);

	/* Now we can actually change the self signature(s) */
	main_pk = NULL;
	uid = NULL;
	selected = 0;
	for (node = pub_keyblock; node; node = node->next)
	{
	if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
	break; /* No more user-ids expected - ready. */

	if (node->pkt->pkttype == PKT_PUBLIC_KEY)
	{
	main_pk = node->pkt->pkt.public_key;
	keyid_from_pk (main_pk, keyid);
	}
	else if (node->pkt->pkttype == PKT_USER_ID)
	{
	uid = node->pkt->pkt.user_id;
	selected = select_all \|\| (node->flag & NODFLG_SELUID);
	}
	else if (main_pk && uid && selected
	&& node->pkt->pkttype == PKT_SIGNATURE)
	{
	PKT_signature *sig = node->pkt->pkt.signature;
	if (keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1]
	&& (uid && (sig->sig_class & ~3) == 0x10)
	&& sig->flags.chosen_selfsig)
	{
	if (sig->version < 4)
	{
	char *user =
	utf8_to_native (uid->name, strlen (uid->name), 0);

	log_info (_("skipping v3 self-signature on user ID \"%s\"\n"),
	user);
	xfree (user);
	}
	else
	{
	/* This is a selfsignature which is to be replaced
	* We have to ignore v3 signatures because they are
	* not able to carry the preferences. */
	PKT_signature *newsig;
	PACKET *newpkt;
	int rc;

	rc = update_keysig_packet (ctrl, &newsig, sig,
	main_pk, uid, NULL, main_pk,
	keygen_upd_std_prefs, NULL);
	if (rc)
	{
	log_error ("update_keysig_packet failed: %s\n",
	gpg_strerror (rc));
	return 0;
	}
	/* replace the packet */
	newpkt = xmalloc_clear (sizeof *newpkt);
	newpkt->pkttype = PKT_SIGNATURE;
	newpkt->pkt.signature = newsig;
	free_packet (node->pkt, NULL);
	xfree (node->pkt);
	node->pkt = newpkt;
	modified = 1;
	}
	}
	}
	}

	return modified;
	}


	static int
	menu_set_keyserver_url (ctrl_t ctrl, const char *url, kbnode_t pub_keyblock)
	{
	PKT_public_key *main_pk;
	PKT_user_id *uid;
	KBNODE node;
	u32 keyid[2];
	int selected, select_all;
	int modified = 0;
	char answer, uri;

	no_primary_warning (pub_keyblock);

	if (url)
	answer = xstrdup (url);
	else
	{
	answer = cpr_get_utf8 ("keyedit.add_keyserver",
	_("Enter your preferred keyserver URL: "));
	if (answer[0] == '\0' \|\| answer[0] == CONTROL_D)
	{
	xfree (answer);
	return 0;
	}
	}

	if (ascii_strcasecmp (answer, "none") == 0)
	uri = NULL;
	else
	{
	struct keyserver_spec *keyserver = NULL;
	/* Sanity check the format */
	keyserver = parse_keyserver_uri (answer, 1);
	xfree (answer);
	if (!keyserver)
	{
	log_info (_("could not parse keyserver URL\n"));
	return 0;
	}
	uri = xstrdup (keyserver->uri);
	free_keyserver_spec (keyserver);
	}

	select_all = !count_selected_uids (pub_keyblock);

	/* Now we can actually change the self signature(s) */
	main_pk = NULL;
	uid = NULL;
	selected = 0;
	for (node = pub_keyblock; node; node = node->next)
	{
	if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
	break; /* ready */

	if (node->pkt->pkttype == PKT_PUBLIC_KEY)
	{
	main_pk = node->pkt->pkt.public_key;
	keyid_from_pk (main_pk, keyid);
	}
	else if (node->pkt->pkttype == PKT_USER_ID)
	{
	uid = node->pkt->pkt.user_id;
	selected = select_all \|\| (node->flag & NODFLG_SELUID);
	}
	else if (main_pk && uid && selected
	&& node->pkt->pkttype == PKT_SIGNATURE)
	{
	PKT_signature *sig = node->pkt->pkt.signature;
	if (keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1]
	&& (uid && (sig->sig_class & ~3) == 0x10)
	&& sig->flags.chosen_selfsig)
	{
	char *user = utf8_to_native (uid->name, strlen (uid->name), 0);
	if (sig->version < 4)
	log_info (_("skipping v3 self-signature on user ID \"%s\"\n"),
	user);
	else
	{
	/* This is a selfsignature which is to be replaced
	* We have to ignore v3 signatures because they are
	* not able to carry the subpacket. */
	PKT_signature *newsig;
	PACKET *newpkt;
	int rc;
	const byte *p;
	size_t plen;

	p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_PREF_KS, &plen);
	if (p && plen)
	{
	tty_printf ("Current preferred keyserver for user"
	" ID \"%s\": ", user);
	tty_print_utf8_string (p, plen);
	tty_printf ("\n");
	if (!cpr_get_answer_is_yes
	("keyedit.confirm_keyserver",
	uri
	? _("Are you sure you want to replace it? (y/N) ")
	: _("Are you sure you want to delete it? (y/N) ")))
	continue;
	}
	else if (uri == NULL)
	{
	/* There is no current keyserver URL, so there
	is no point in trying to un-set it. */
	continue;
	}

	rc = update_keysig_packet (ctrl, &newsig, sig,
	main_pk, uid, NULL,
	main_pk,
	keygen_add_keyserver_url, uri);
	if (rc)
	{
	log_error ("update_keysig_packet failed: %s\n",
	gpg_strerror (rc));
	xfree (uri);
	return 0;
	}
	/* replace the packet */
	newpkt = xmalloc_clear (sizeof *newpkt);
	newpkt->pkttype = PKT_SIGNATURE;
	newpkt->pkt.signature = newsig;
	free_packet (node->pkt, NULL);
	xfree (node->pkt);
	node->pkt = newpkt;
	modified = 1;
	}

	xfree (user);
	}
	}
	}

	xfree (uri);
	return modified;
	}


	static int
	menu_set_notation (ctrl_t ctrl, const char *string, KBNODE pub_keyblock)
	{
	PKT_public_key *main_pk;
	PKT_user_id *uid;
	KBNODE node;
	u32 keyid[2];
	int selected, select_all;
	int modified = 0;
	char *answer;
	struct notation *notation;

	no_primary_warning (pub_keyblock);

	if (string)
	answer = xstrdup (string);
	else
	{
	answer = cpr_get_utf8 ("keyedit.add_notation",
	_("Enter the notation: "));
	if (answer[0] == '\0' \|\| answer[0] == CONTROL_D)
	{
	xfree (answer);
	return 0;
	}
	}

	if (!ascii_strcasecmp (answer, "none")
	\|\| !ascii_strcasecmp (answer, "-"))
	notation = NULL; /* Delete them all. */
	else
	{
	notation = string_to_notation (answer, 0);
	if (!notation)
	{
	xfree (answer);
	return 0;
	}
	}

	xfree (answer);

	select_all = !count_selected_uids (pub_keyblock);

	/* Now we can actually change the self signature(s) */
	main_pk = NULL;
	uid = NULL;
	selected = 0;
	for (node = pub_keyblock; node; node = node->next)
	{
	if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
	break; /* ready */

	if (node->pkt->pkttype == PKT_PUBLIC_KEY)
	{
	main_pk = node->pkt->pkt.public_key;
	keyid_from_pk (main_pk, keyid);
	}
	else if (node->pkt->pkttype == PKT_USER_ID)
	{
	uid = node->pkt->pkt.user_id;
	selected = select_all \|\| (node->flag & NODFLG_SELUID);
	}
	else if (main_pk && uid && selected
	&& node->pkt->pkttype == PKT_SIGNATURE)
	{
	PKT_signature *sig = node->pkt->pkt.signature;
	if (keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1]
	&& (uid && (sig->sig_class & ~3) == 0x10)
	&& sig->flags.chosen_selfsig)
	{
	char *user = utf8_to_native (uid->name, strlen (uid->name), 0);
	if (sig->version < 4)
	log_info (_("skipping v3 self-signature on user ID \"%s\"\n"),
	user);
	else
	{
	PKT_signature *newsig;
	PACKET *newpkt;
	int rc, skip = 0, addonly = 1;

	if (sig->flags.notation)
	{
	tty_printf ("Current notations for user ID \"%s\":\n",
	user);
	tty_print_notations (-9, sig);
	}
	else
	{
	tty_printf ("No notations on user ID \"%s\"\n", user);
	if (notation == NULL)
	{
	/* There are no current notations, so there
	is no point in trying to un-set them. */
	continue;
	}
	}

	if (notation)
	{
	struct notation *n;
	int deleting = 0;

	notation->next = sig_to_notation (sig);

	for (n = notation->next; n; n = n->next)
	if (strcmp (n->name, notation->name) == 0)
	{
	if (notation->value)
	{
	if (strcmp (n->value, notation->value) == 0)
	{
	if (notation->flags.ignore)
	{
	/* Value match with a delete
	flag. */
	n->flags.ignore = 1;
	deleting = 1;
	}
	else
	{
	/* Adding the same notation
	twice, so don't add it at
	all. */
	skip = 1;
	tty_printf ("Skipping notation:"
	" %s=%s\n",
	notation->name,
	notation->value);
	break;
	}
	}
	}
	else
	{
	/* No value, so it means delete. */
	n->flags.ignore = 1;
	deleting = 1;
	}

	if (n->flags.ignore)
	{
	tty_printf ("Removing notation: %s=%s\n",
	n->name, n->value);
	addonly = 0;
	}
	}

	if (!notation->flags.ignore && !skip)
	tty_printf ("Adding notation: %s=%s\n",
	notation->name, notation->value);

	/* We tried to delete, but had no matches. */
	if (notation->flags.ignore && !deleting)
	continue;
	}
	else
	{
	tty_printf ("Removing all notations\n");
	addonly = 0;
	}

	if (skip
	\|\| (!addonly
	&&
	!cpr_get_answer_is_yes ("keyedit.confirm_notation",
	_("Proceed? (y/N) "))))
	continue;

	rc = update_keysig_packet (ctrl, &newsig, sig,
	main_pk, uid, NULL,
	main_pk,
	keygen_add_notations, notation);
	if (rc)
	{
	log_error ("update_keysig_packet failed: %s\n",
	gpg_strerror (rc));
	free_notation (notation);
	xfree (user);
	return 0;
	}

	/* replace the packet */
	newpkt = xmalloc_clear (sizeof *newpkt);
	newpkt->pkttype = PKT_SIGNATURE;
	newpkt->pkt.signature = newsig;
	free_packet (node->pkt, NULL);
	xfree (node->pkt);
	node->pkt = newpkt;
	modified = 1;

	if (notation)
	{
	/* Snip off the notation list from the sig */
	free_notation (notation->next);
	notation->next = NULL;
	}

	xfree (user);
	}
	}
	}
	}

	free_notation (notation);
	return modified;
	}


	/*
	* Select one user id or remove all selection if IDX is 0 or select
	* all if IDX is -1. Returns: True if the selection changed.
	*/
	static int
	menu_select_uid (KBNODE keyblock, int idx)
	{
	KBNODE node;
	int i;

	if (idx == -1) /* Select all. */
	{
	for (node = keyblock; node; node = node->next)
	if (node->pkt->pkttype == PKT_USER_ID)
	node->flag \|= NODFLG_SELUID;
	return 1;
	}
	else if (idx) /* Toggle. */
	{
	for (i = 0, node = keyblock; node; node = node->next)
	{
	if (node->pkt->pkttype == PKT_USER_ID)
	if (++i == idx)
	break;
	}
	if (!node)
	{
	tty_printf (_("No user ID with index %d\n"), idx);
	return 0;
	}

	for (i = 0, node = keyblock; node; node = node->next)
	{
	if (node->pkt->pkttype == PKT_USER_ID)
	{
	if (++i == idx)
	{
	if ((node->flag & NODFLG_SELUID))
	node->flag &= ~NODFLG_SELUID;
	else
	node->flag \|= NODFLG_SELUID;
	}
	}
	}
	}
	else /* Unselect all */
	{
	for (node = keyblock; node; node = node->next)
	if (node->pkt->pkttype == PKT_USER_ID)
	node->flag &= ~NODFLG_SELUID;
	}

	return 1;
	}


	/* Search in the keyblock for a uid that matches namehash */
	static int
	menu_select_uid_namehash (KBNODE keyblock, const char *namehash)
	{
	byte hash[NAMEHASH_LEN];
	KBNODE node;
	int i;

	log_assert (strlen (namehash) == NAMEHASH_LEN * 2);

	for (i = 0; i < NAMEHASH_LEN; i++)
	hash[i] = hextobyte (&namehash[i * 2]);

	for (node = keyblock->next; node; node = node->next)
	{
	if (node->pkt->pkttype == PKT_USER_ID)
	{
	namehash_from_uid (node->pkt->pkt.user_id);
	if (memcmp (node->pkt->pkt.user_id->namehash, hash, NAMEHASH_LEN) ==
	0)
	{
	if (node->flag & NODFLG_SELUID)
	node->flag &= ~NODFLG_SELUID;
	else
	node->flag \|= NODFLG_SELUID;

	break;
	}
	}
	}

	if (!node)
	{
	tty_printf (_("No user ID with hash %s\n"), namehash);
	return 0;
	}

	return 1;
	}


	/*
	* Select secondary keys
	* Returns: True if the selection changed.
	*/
	static int
	menu_select_key (KBNODE keyblock, int idx, char *p)
	{
	KBNODE node;
	int i, j;
	int is_hex_digits;

	is_hex_digits = p && strlen (p) >= 8;
	if (is_hex_digits)
	{
	/* Skip initial spaces. */
	while (spacep (p))
	p ++;
	/* If the id starts with 0x accept and ignore it. */
	if (p[0] == '0' && p[1] == 'x')
	p += 2;

	for (i = 0, j = 0; p[i]; i ++)
	if (hexdigitp (&p[i]))
	{
	p[j] = toupper (p[i]);
	j ++;
	}
	else if (spacep (&p[i]))
	/* Skip spaces. */
	{
	}
	else
	{
	is_hex_digits = 0;
	break;
	}
	if (is_hex_digits)
	/* In case we skipped some spaces, add a new NUL terminator. */
	{
	p[j] = 0;
	/* If we skipped some spaces, make sure that we still have
	at least 8 characters. */
	is_hex_digits = (/* Short keyid. */
	strlen (p) == 8
	/* Long keyid. */
	\|\| strlen (p) == 16
	/* Fingerprints are (currently) 32 or 40
	characters. */
	\|\| strlen (p) >= 32);
	}
	}

	if (is_hex_digits)
	{
	int found_one = 0;
	for (node = keyblock; node; node = node->next)
	if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY
	\|\| node->pkt->pkttype == PKT_SECRET_SUBKEY)
	{
	int match = 0;
	if (strlen (p) == 8 \|\| strlen (p) == 16)
	{
	u32 kid[2];
	char kid_str[17];
	keyid_from_pk (node->pkt->pkt.public_key, kid);
	format_keyid (kid, strlen (p) == 8 ? KF_SHORT : KF_LONG,
	kid_str, sizeof (kid_str));

	if (strcmp (p, kid_str) == 0)
	match = 1;
	}
	else
	{
	char fp[2*MAX_FINGERPRINT_LEN + 1];
	hexfingerprint (node->pkt->pkt.public_key, fp, sizeof (fp));
	if (strcmp (fp, p) == 0)
	match = 1;
	}

	if (match)
	{
	if ((node->flag & NODFLG_SELKEY))
	node->flag &= ~NODFLG_SELKEY;
	else
	node->flag \|= NODFLG_SELKEY;

	found_one = 1;
	}
	}

	if (found_one)
	return 1;

	tty_printf (_("No subkey with key ID '%s'.\n"), p);
	return 0;
	}

	if (idx == -1) /* Select all. */
	{
	for (node = keyblock; node; node = node->next)
	if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY
	\|\| node->pkt->pkttype == PKT_SECRET_SUBKEY)
	node->flag \|= NODFLG_SELKEY;
	}
	else if (idx) /* Toggle selection. */
	{
	for (i = 0, node = keyblock; node; node = node->next)
	{
	if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY
	\|\| node->pkt->pkttype == PKT_SECRET_SUBKEY)
	if (++i == idx)
	break;
	}
	if (!node)
	{
	tty_printf (_("No subkey with index %d\n"), idx);
	return 0;
	}

	for (i = 0, node = keyblock; node; node = node->next)
	{
	if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY
	\|\| node->pkt->pkttype == PKT_SECRET_SUBKEY)
	if (++i == idx)
	{
	if ((node->flag & NODFLG_SELKEY))
	node->flag &= ~NODFLG_SELKEY;
	else
	node->flag \|= NODFLG_SELKEY;
	}
	}
	}
	else /* Unselect all. */
	{
	for (node = keyblock; node; node = node->next)
	if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY
	\|\| node->pkt->pkttype == PKT_SECRET_SUBKEY)
	node->flag &= ~NODFLG_SELKEY;
	}

	return 1;
	}


	static int
	count_uids_with_flag (KBNODE keyblock, unsigned flag)
	{
	KBNODE node;
	int i = 0;

	for (node = keyblock; node; node = node->next)
	if (node->pkt->pkttype == PKT_USER_ID && (node->flag & flag))
	i++;
	return i;
	}


	static int
	count_keys_with_flag (KBNODE keyblock, unsigned flag)
	{
	KBNODE node;
	int i = 0;

	for (node = keyblock; node; node = node->next)
	if ((node->pkt->pkttype == PKT_PUBLIC_SUBKEY
	\|\| node->pkt->pkttype == PKT_SECRET_SUBKEY) && (node->flag & flag))
	i++;
	return i;
	}


	static int
	count_uids (KBNODE keyblock)
	{
	KBNODE node;
	int i = 0;

	for (node = keyblock; node; node = node->next)
	if (node->pkt->pkttype == PKT_USER_ID)
	i++;
	return i;
	}


	/*
	* Returns true if there is at least one selected user id
	*/
	static int
	count_selected_uids (KBNODE keyblock)
	{
	return count_uids_with_flag (keyblock, NODFLG_SELUID);
	}


	static int
	count_selected_keys (KBNODE keyblock)
	{
	return count_keys_with_flag (keyblock, NODFLG_SELKEY);
	}


	/* Returns how many real (i.e. not attribute) uids are unmarked. */
	static int
	real_uids_left (KBNODE keyblock)
	{
	KBNODE node;
	int real = 0;

	for (node = keyblock; node; node = node->next)
	if (node->pkt->pkttype == PKT_USER_ID && !(node->flag & NODFLG_SELUID) &&
	!node->pkt->pkt.user_id->attrib_data)
	real++;

	return real;
	}


	/*
	* Ask whether the signature should be revoked. If the user commits this,
	* flag bit MARK_A is set on the signature and the user ID.
	*/
	static void
	ask_revoke_sig (ctrl_t ctrl, kbnode_t keyblock, kbnode_t node)
	{
	int doit = 0;
	PKT_user_id *uid;
	PKT_signature *sig = node->pkt->pkt.signature;
	KBNODE unode = find_prev_kbnode (keyblock, node, PKT_USER_ID);

	if (!unode)
	{
	log_error ("Oops: no user ID for signature\n");
	return;
	}

	uid = unode->pkt->pkt.user_id;

	if (opt.with_colons)
	{
	if (uid->attrib_data)
	printf ("uat:::::::::%u %lu", uid->numattribs, uid->attrib_len);
	else
	{
	es_printf ("uid:::::::::");
	es_write_sanitized (es_stdout, uid->name, uid->len, ":", NULL);
	}

	es_printf ("\n");

	print_and_check_one_sig_colon (ctrl, keyblock, node,
	NULL, NULL, NULL, NULL, 1);
	}
	else
	{
	char *p = utf8_to_native (unode->pkt->pkt.user_id->name,
	unode->pkt->pkt.user_id->len, 0);
	tty_printf (_("user ID: \"%s\"\n"), p);
	xfree (p);

	tty_printf (_("signed by your key %s on %s%s%s\n"),
	keystr (sig->keyid), datestr_from_sig (sig),
	sig->flags.exportable ? "" : _(" (non-exportable)"), "");
	}
	if (sig->flags.expired)
	{
	tty_printf (_("This signature expired on %s.\n"),
	expirestr_from_sig (sig));
	/* Use a different question so we can have different help text */
	doit = cpr_get_answer_is_yes
	("ask_revoke_sig.expired",
	_("Are you sure you still want to revoke it? (y/N) "));
	}
	else
	doit = cpr_get_answer_is_yes
	("ask_revoke_sig.one",
	_("Create a revocation certificate for this signature? (y/N) "));

	if (doit)
	{
	node->flag \|= NODFLG_MARK_A;
	unode->flag \|= NODFLG_MARK_A;
	}
	}


	/*
	* Display all user ids of the current public key together with signatures
	* done by one of our keys. Then walk over all this sigs and ask the user
	* whether he wants to revoke this signature.
	* Return: True when the keyblock has changed.
	*/
	static int
	menu_revsig (ctrl_t ctrl, kbnode_t keyblock)
	{
	PKT_signature *sig;
	PKT_public_key *primary_pk;
	KBNODE node;
	int changed = 0;
	int rc, any, skip = 1, all = !count_selected_uids (keyblock);
	struct revocation_reason_info *reason = NULL;

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

	/* First check whether we have any signatures at all. */
	any = 0;
	for (node = keyblock; node; node = node->next)
	{
	node->flag &= ~(NODFLG_SELSIG \| NODFLG_MARK_A);
	if (node->pkt->pkttype == PKT_USER_ID)
	{
	if (node->flag & NODFLG_SELUID \|\| all)
	skip = 0;
	else
	skip = 1;
	}
	else if (!skip && node->pkt->pkttype == PKT_SIGNATURE
	&& ((sig = node->pkt->pkt.signature),
	have_secret_key_with_kid (sig->keyid)))
	{
	if ((sig->sig_class & ~3) == 0x10)
	{
	any = 1;
	break;
	}
	}
	}

	if (!any)
	{
	tty_printf (_("Not signed by you.\n"));
	return 0;
	}


	/* FIXME: detect duplicates here */
	tty_printf (_("You have signed these user IDs on key %s:\n"),
	keystr_from_pk (keyblock->pkt->pkt.public_key));
	for (node = keyblock; node; node = node->next)
	{
	node->flag &= ~(NODFLG_SELSIG \| NODFLG_MARK_A);
	if (node->pkt->pkttype == PKT_USER_ID)
	{
	if (node->flag & NODFLG_SELUID \|\| all)
	{
	PKT_user_id *uid = node->pkt->pkt.user_id;
	/* Hmmm: Should we show only UIDs with a signature? */
	tty_printf (" ");
	tty_print_utf8_string (uid->name, uid->len);
	tty_printf ("\n");
	skip = 0;
	}
	else
	skip = 1;
	}
	else if (!skip && node->pkt->pkttype == PKT_SIGNATURE
	&& ((sig = node->pkt->pkt.signature),
	have_secret_key_with_kid (sig->keyid)))
	{
	if ((sig->sig_class & ~3) == 0x10)
	{
	tty_printf (" ");
	tty_printf (_("signed by your key %s on %s%s%s\n"),
	keystr (sig->keyid), datestr_from_sig (sig),
	sig->flags.exportable ? "" : _(" (non-exportable)"),
	sig->flags.revocable ? "" : _(" (non-revocable)"));
	if (sig->flags.revocable)
	node->flag \|= NODFLG_SELSIG;
	}
	else if (sig->sig_class == 0x30)
	{
	tty_printf (" ");
	tty_printf (_("revoked by your key %s on %s\n"),
	keystr (sig->keyid), datestr_from_sig (sig));
	}
	}
	}

	tty_printf ("\n");

	/* ask */
	for (node = keyblock; node; node = node->next)
	{
	if (!(node->flag & NODFLG_SELSIG))
	continue;
	ask_revoke_sig (ctrl, keyblock, node);
	}

	/* present selected */
	any = 0;
	for (node = keyblock; node; node = node->next)
	{
	if (!(node->flag & NODFLG_MARK_A))
	continue;
	if (!any)
	{
	any = 1;
	tty_printf (_("You are about to revoke these signatures:\n"));
	}
	if (node->pkt->pkttype == PKT_USER_ID)
	{
	PKT_user_id *uid = node->pkt->pkt.user_id;
	tty_printf (" ");
	tty_print_utf8_string (uid->name, uid->len);
	tty_printf ("\n");
	}
	else if (node->pkt->pkttype == PKT_SIGNATURE)
	{
	sig = node->pkt->pkt.signature;
	tty_printf (" ");
	tty_printf (_("signed by your key %s on %s%s%s\n"),
	keystr (sig->keyid), datestr_from_sig (sig), "",
	sig->flags.exportable ? "" : _(" (non-exportable)"));
	}
	}
	if (!any)
	return 0; /* none selected */

	if (!cpr_get_answer_is_yes
	("ask_revoke_sig.okay",
	_("Really create the revocation certificates? (y/N) ")))
	return 0; /* forget it */

	reason = ask_revocation_reason (0, 1, 0);
	if (!reason)
	{ /* user decided to cancel */
	return 0;
	}

	/* now we can sign the user ids */
	reloop: /* (must use this, because we are modifying the list) */
	primary_pk = keyblock->pkt->pkt.public_key;
	for (node = keyblock; node; node = node->next)
	{
	KBNODE unode;
	PACKET *pkt;
	struct sign_attrib attrib;
	PKT_public_key *signerkey;

	if (!(node->flag & NODFLG_MARK_A)
	\|\| node->pkt->pkttype != PKT_SIGNATURE)
	continue;
	unode = find_prev_kbnode (keyblock, node, PKT_USER_ID);
	log_assert (unode); /* we already checked this */

	memset (&attrib, 0, sizeof attrib);
	attrib.reason = reason;
	attrib.non_exportable = !node->pkt->pkt.signature->flags.exportable;

	node->flag &= ~NODFLG_MARK_A;
	signerkey = xmalloc_secure_clear (sizeof *signerkey);
	if (get_seckey (ctrl, signerkey, node->pkt->pkt.signature->keyid))
	{
	log_info (_("no secret key\n"));
	free_public_key (signerkey);
	continue;
	}
	rc = make_keysig_packet (ctrl, &sig, primary_pk,
	unode->pkt->pkt.user_id,
	NULL, signerkey, 0x30, 0, 0, 0,
	sign_mk_attrib, &attrib, NULL);
	free_public_key (signerkey);
	if (rc)
	{
	write_status_error ("keysig", rc);
	log_error (_("signing failed: %s\n"), gpg_strerror (rc));
	release_revocation_reason_info (reason);
	return changed;
	}
	changed = 1; /* we changed the keyblock */
	update_trust = 1;
	/* Are we revoking our own uid? */
	if (primary_pk->keyid[0] == sig->keyid[0] &&
	primary_pk->keyid[1] == sig->keyid[1])
	unode->pkt->pkt.user_id->flags.revoked = 1;
	pkt = xmalloc_clear (sizeof *pkt);
	pkt->pkttype = PKT_SIGNATURE;
	pkt->pkt.signature = sig;
	insert_kbnode (unode, new_kbnode (pkt), 0);
	goto reloop;
	}

	release_revocation_reason_info (reason);
	return changed;
	}


	/* return 0 if revocation of NODE (which must be a User ID) was
	successful, non-zero if there was an error. *modified will be set
	to 1 if a change was made. */
	static int
	core_revuid (ctrl_t ctrl, kbnode_t keyblock, KBNODE node,
	const struct revocation_reason_info reason, int modified)
	{
	PKT_public_key *pk = keyblock->pkt->pkt.public_key;
	gpg_error_t rc;

	if (node->pkt->pkttype != PKT_USER_ID)
	{
	rc = gpg_error (GPG_ERR_NO_USER_ID);
	write_status_error ("keysig", rc);
	log_error (_("tried to revoke a non-user ID: %s\n"), gpg_strerror (rc));
	return 1;
	}
	else
	{
	PKT_user_id *uid = node->pkt->pkt.user_id;

	if (uid->flags.revoked)
	{
	char *user = utf8_to_native (uid->name, uid->len, 0);
	log_info (_("user ID \"%s\" is already revoked\n"), user);
	xfree (user);
	}
	else
	{
	PACKET *pkt;
	PKT_signature *sig;
	struct sign_attrib attrib;
	u32 timestamp = make_timestamp ();

	if (uid->created >= timestamp)
	{
	/* Okay, this is a problem. The user ID selfsig was
	created in the future, so we need to warn the user and
	set our revocation timestamp one second after that so
	everything comes out clean. */

	log_info (_("WARNING: a user ID signature is dated %d"
	" seconds in the future\n"),
	uid->created - timestamp);

	timestamp = uid->created + 1;
	}

	memset (&attrib, 0, sizeof attrib);
	/* should not need to cast away const here; but
	revocation_reason_build_cb needs to take a non-const
	void* in order to meet the function signtuare for the
	mksubpkt argument to make_keysig_packet */
	attrib.reason = (struct revocation_reason_info *)reason;

	rc = make_keysig_packet (ctrl, &sig, pk, uid, NULL, pk, 0x30, 0,
	timestamp, 0,
	sign_mk_attrib, &attrib, NULL);
	if (rc)
	{
	write_status_error ("keysig", rc);
	log_error (_("signing failed: %s\n"), gpg_strerror (rc));
	return 1;
	}
	else
	{
	pkt = xmalloc_clear (sizeof *pkt);
	pkt->pkttype = PKT_SIGNATURE;
	pkt->pkt.signature = sig;
	insert_kbnode (node, new_kbnode (pkt), 0);

	#ifndef NO_TRUST_MODELS
	/* If the trustdb has an entry for this key+uid then the
	trustdb needs an update. */
	if (!update_trust
	&& ((get_validity (ctrl, keyblock, pk, uid, NULL, 0)
	& TRUST_MASK)
	>= TRUST_UNDEFINED))
	update_trust = 1;
	#endif /!NO_TRUST_MODELS/

	node->pkt->pkt.user_id->flags.revoked = 1;
	if (modified)
	*modified = 1;
	}
	}
	return 0;
	}
	}

	/* Revoke a user ID (i.e. revoke a user ID selfsig). Return true if
	keyblock changed. */
	static int
	menu_revuid (ctrl_t ctrl, kbnode_t pub_keyblock)
	{
	PKT_public_key *pk = pub_keyblock->pkt->pkt.public_key;
	KBNODE node;
	int changed = 0;
	int rc;
	struct revocation_reason_info *reason = NULL;
	size_t valid_uids;

	/* Note that this is correct as per the RFCs, but nevertheless
	somewhat meaningless in the real world. 1991 did define the 0x30
	sig class, but PGP 2.x did not actually implement it, so it would
	probably be safe to use v4 revocations everywhere. -ds */

	for (node = pub_keyblock; node; node = node->next)
	if (pk->version > 3 \|\| (node->pkt->pkttype == PKT_USER_ID &&
	node->pkt->pkt.user_id->selfsigversion > 3))
	{
	if ((reason = ask_revocation_reason (0, 1, 4)))
	break;
	else
	goto leave;
	}

	/* Too make sure that we do not revoke the last valid UID, we first
	count how many valid UIDs there are. */
	valid_uids = 0;
	for (node = pub_keyblock; node; node = node->next)
	valid_uids +=
	node->pkt->pkttype == PKT_USER_ID
	&& ! node->pkt->pkt.user_id->flags.revoked
	&& ! node->pkt->pkt.user_id->flags.expired;

	reloop: /* (better this way because we are modifying the keyring) */
	for (node = pub_keyblock; node; node = node->next)
	if (node->pkt->pkttype == PKT_USER_ID && (node->flag & NODFLG_SELUID))
	{
	int modified = 0;

	/* Make sure that we do not revoke the last valid UID. */
	if (valid_uids == 1
	&& ! node->pkt->pkt.user_id->flags.revoked
	&& ! node->pkt->pkt.user_id->flags.expired)
	{
	log_error (_("Cannot revoke the last valid user ID.\n"));
	goto leave;
	}

	rc = core_revuid (ctrl, pub_keyblock, node, reason, &modified);
	if (rc)
	goto leave;
	if (modified)
	{
	node->flag &= ~NODFLG_SELUID;
	changed = 1;
	goto reloop;
	}
	}

	if (changed)
	commit_kbnode (&pub_keyblock);

	leave:
	release_revocation_reason_info (reason);
	return changed;
	}


	/*
	* Revoke the whole key.
	*/
	static int
	menu_revkey (ctrl_t ctrl, kbnode_t pub_keyblock)
	{
	PKT_public_key *pk = pub_keyblock->pkt->pkt.public_key;
	int rc, changed = 0;
	struct revocation_reason_info *reason;
	PACKET *pkt;
	PKT_signature *sig;

	if (pk->flags.revoked)
	{
	tty_printf (_("Key %s is already revoked.\n"), keystr_from_pk (pk));
	return 0;
	}

	reason = ask_revocation_reason (1, 0, 0);
	/* user decided to cancel */
	if (!reason)
	return 0;

	rc = make_keysig_packet (ctrl, &sig, pk, NULL, NULL, pk,
	0x20, 0, 0, 0,
	revocation_reason_build_cb, reason, NULL);
	if (rc)
	{
	write_status_error ("keysig", rc);
	log_error (_("signing failed: %s\n"), gpg_strerror (rc));
	goto scram;
	}

	changed = 1; /* we changed the keyblock */

	pkt = xmalloc_clear (sizeof *pkt);
	pkt->pkttype = PKT_SIGNATURE;
	pkt->pkt.signature = sig;
	insert_kbnode (pub_keyblock, new_kbnode (pkt), 0);
	commit_kbnode (&pub_keyblock);

	update_trust = 1;

	scram:
	release_revocation_reason_info (reason);
	return changed;
	}


	static int
	menu_revsubkey (ctrl_t ctrl, kbnode_t pub_keyblock)
	{
	PKT_public_key *mainpk;
	KBNODE node;
	int changed = 0;
	int rc;
	struct revocation_reason_info *reason = NULL;

	reason = ask_revocation_reason (1, 0, 0);
	if (!reason)
	return 0; /* User decided to cancel. */

	reloop: /* (better this way because we are modifying the keyring) */
	mainpk = pub_keyblock->pkt->pkt.public_key;
	for (node = pub_keyblock; node; node = node->next)
	{
	if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY
	&& (node->flag & NODFLG_SELKEY))
	{
	PACKET *pkt;
	PKT_signature *sig;
	PKT_public_key *subpk = node->pkt->pkt.public_key;
	struct sign_attrib attrib;

	if (subpk->flags.revoked)
	{
	tty_printf (_("Subkey %s is already revoked.\n"),
	keystr_from_pk (subpk));
	continue;
	}

	memset (&attrib, 0, sizeof attrib);
	attrib.reason = reason;

	node->flag &= ~NODFLG_SELKEY;
	rc = make_keysig_packet (ctrl, &sig, mainpk, NULL, subpk, mainpk,
	0x28, 0, 0, 0, sign_mk_attrib, &attrib,
	NULL);
	if (rc)
	{
	write_status_error ("keysig", rc);
	log_error (_("signing failed: %s\n"), gpg_strerror (rc));
	release_revocation_reason_info (reason);
	return changed;
	}
	changed = 1; /* we changed the keyblock */

	pkt = xmalloc_clear (sizeof *pkt);
	pkt->pkttype = PKT_SIGNATURE;
	pkt->pkt.signature = sig;
	insert_kbnode (node, new_kbnode (pkt), 0);
	goto reloop;
	}
	}
	commit_kbnode (&pub_keyblock);

	/* No need to set update_trust here since signing keys no longer
	are used to certify other keys, so there is no change in trust
	when revoking/removing them */

	release_revocation_reason_info (reason);
	return changed;
	}


	/* Note that update_ownertrust is going to mark the trustdb dirty when
	enabling or disabling a key. This is arguably sub-optimal as
	disabled keys are still counted in the web of trust, but perhaps
	not worth adding extra complexity to change. -ds */
	#ifndef NO_TRUST_MODELS
	static int
	enable_disable_key (ctrl_t ctrl, kbnode_t keyblock, int disable)
	{
	PKT_public_key *pk =
	find_kbnode (keyblock, PKT_PUBLIC_KEY)->pkt->pkt.public_key;
	unsigned int trust, newtrust;

	trust = newtrust = get_ownertrust (ctrl, pk);
	newtrust &= ~TRUST_FLAG_DISABLED;
	if (disable)
	newtrust \|= TRUST_FLAG_DISABLED;
	if (trust == newtrust)
	return 0; /* already in that state */
	update_ownertrust (ctrl, pk, newtrust);
	return 0;
	}
	#endif /!NO_TRUST_MODELS/


	static void
	menu_showphoto (ctrl_t ctrl, kbnode_t keyblock)
	{
	KBNODE node;
	int select_all = !count_selected_uids (keyblock);
	int count = 0;
	PKT_public_key *pk = NULL;

	/* Look for the public key first. We have to be really, really,
	explicit as to which photo this is, and what key it is a UID on
	since people may want to sign it. */

	for (node = keyblock; node; node = node->next)
	{
	if (node->pkt->pkttype == PKT_PUBLIC_KEY)
	pk = node->pkt->pkt.public_key;
	else if (node->pkt->pkttype == PKT_USER_ID)
	{
	PKT_user_id *uid = node->pkt->pkt.user_id;
	count++;

	if ((select_all \|\| (node->flag & NODFLG_SELUID)) &&
	uid->attribs != NULL)
	{
	int i;

	for (i = 0; i < uid->numattribs; i++)
	{
	byte type;
	u32 size;

	if (uid->attribs[i].type == ATTRIB_IMAGE &&
	parse_image_header (&uid->attribs[i], &type, &size))
	{
	tty_printf (_("Displaying %s photo ID of size %ld for "
	"key %s (uid %d)\n"),
	image_type_to_string (type, 1),
	(ulong) size, keystr_from_pk (pk), count);
	show_photos (ctrl, &uid->attribs[i], 1, pk, uid);
	}
	}
	}
	}
	}
	}
	diff --git a/g10/packet.h b/g10/packet.h
	index b7ceb6479..187fffc7c 100644
	--- a/g10/packet.h
	+++ b/g10/packet.h
	@@ -1,941 +1,942 @@
	/* packet.h - OpenPGP packet definitions
	* Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
	* 2007 Free Software Foundation, Inc.
	* Copyright (C) 2015 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_PACKET_H
	#define G10_PACKET_H

	#include "../common/types.h"
	#include "../common/iobuf.h"
	#include "../common/strlist.h"
	#include "dek.h"
	#include "filter.h"
	#include "../common/openpgpdefs.h"
	#include "../common/userids.h"
	#include "../common/util.h"

	#define DEBUG_PARSE_PACKET 1

	/* Maximum length of packets to avoid excessive memory allocation. */
	#define MAX_KEY_PACKET_LENGTH (256 * 1024)
	#define MAX_UID_PACKET_LENGTH ( 2 * 1024)
	#define MAX_COMMENT_PACKET_LENGTH ( 64 * 1024)
	#define MAX_ATTR_PACKET_LENGTH ( 16 * 1024*1024)

	/* Constants to allocate static MPI arrays. */
	#define PUBKEY_MAX_NPKEY OPENPGP_MAX_NPKEY
	#define PUBKEY_MAX_NSKEY OPENPGP_MAX_NSKEY
	#define PUBKEY_MAX_NSIG OPENPGP_MAX_NSIG
	#define PUBKEY_MAX_NENC OPENPGP_MAX_NENC

	/* Usage flags */
	#define PUBKEY_USAGE_SIG GCRY_PK_USAGE_SIGN /* Good for signatures. */
	#define PUBKEY_USAGE_ENC GCRY_PK_USAGE_ENCR /* Good for encryption. */
	#define PUBKEY_USAGE_CERT GCRY_PK_USAGE_CERT /* Also good to certify keys.*/
	#define PUBKEY_USAGE_AUTH GCRY_PK_USAGE_AUTH /* Good for authentication. */
	#define PUBKEY_USAGE_UNKNOWN GCRY_PK_USAGE_UNKN /* Unknown usage flag. */
	#define PUBKEY_USAGE_NONE 256 /* No usage given. */
	#if (GCRY_PK_USAGE_SIGN \| GCRY_PK_USAGE_ENCR \| GCRY_PK_USAGE_CERT \
	\| GCRY_PK_USAGE_AUTH \| GCRY_PK_USAGE_UNKN) >= 256
	# error Please choose another value for PUBKEY_USAGE_NONE
	#endif

	/* Helper macros. */
	#define is_RSA(a) ((a)==PUBKEY_ALGO_RSA \|\| (a)==PUBKEY_ALGO_RSA_E \
	\|\| (a)==PUBKEY_ALGO_RSA_S )
	#define is_ELGAMAL(a) ((a)==PUBKEY_ALGO_ELGAMAL_E)
	#define is_DSA(a) ((a)==PUBKEY_ALGO_DSA)

	/* A pointer to the packet object. */
	typedef struct packet_struct PACKET;

	/* PKT_GPG_CONTROL types */
	typedef enum {
	CTRLPKT_CLEARSIGN_START = 1,
	CTRLPKT_PIPEMODE = 2,
	CTRLPKT_PLAINTEXT_MARK =3
	} ctrlpkttype_t;

	typedef enum {
	PREFTYPE_NONE = 0,
	PREFTYPE_SYM = 1,
	PREFTYPE_HASH = 2,
	- PREFTYPE_ZIP = 3
	+ PREFTYPE_ZIP = 3,
	+ PREFTYPE_AEAD = 4
	} preftype_t;

	typedef struct {
	byte type;
	byte value;
	} prefitem_t;

	/* A string-to-key specifier as defined in RFC 4880, Section 3.7. */
	typedef struct
	{
	int mode; /* Must be an integer due to the GNU modes 1001 et al. */
	byte hash_algo;
	byte salt[8];
	/* The coded (i.e., the serialized version) iteration count. */
	u32 count;
	} STRING2KEY;

	/* A symmetric-key encrypted session key packet as defined in RFC
	4880, Section 5.3. All fields are serialized. */
	typedef struct {
	/* RFC 4880: this must be 4. */
	byte version;
	/* The cipher algorithm used to encrypt the session key. (This may
	be different from the algorithm that is used to encrypt the SED
	packet.) */
	byte cipher_algo;
	/* The AEAD algorithm or 0 for CFB encryption. */
	byte aead_algo;
	/* The string-to-key specifier. */
	STRING2KEY s2k;
	/* The length of SESKEY in bytes or 0 if this packet does not
	encrypt a session key. (In the latter case, the results of the
	S2K function on the password is the session key. See RFC 4880,
	Section 5.3.) */
	byte seskeylen;
	/* The session key as encrypted by the S2K specifier. For AEAD this
	* includes the nonce and the authentication tag. */
	byte seskey[1];
	} PKT_symkey_enc;

	/* A public-key encrypted session key packet as defined in RFC 4880,
	Section 5.1. All fields are serialized. */
	typedef struct {
	/* The 64-bit keyid. */
	u32 keyid[2];
	/* The packet's version. Currently, only version 3 is defined. */
	byte version;
	/* The algorithm used for the public key encryption scheme. */
	byte pubkey_algo;
	/* Whether to hide the key id. This value is not directly
	serialized. */
	byte throw_keyid;
	/* The session key. */
	gcry_mpi_t data[PUBKEY_MAX_NENC];
	} PKT_pubkey_enc;


	/* A one-pass signature packet as defined in RFC 4880, Section
	5.4. All fields are serialized. */
	typedef struct {
	u32 keyid[2]; /* The 64-bit keyid */
	/* The signature's classification (RFC 4880, Section 5.2.1). */
	byte sig_class;
	byte digest_algo; /* algorithm used for digest */
	byte pubkey_algo; /* algorithm used for public key scheme */
	/* A message can be signed by multiple keys. In this case, there
	are n one-pass signature packets before the message to sign and
	n signatures packets after the message. It is conceivable that
	someone wants to not only sign the message, but all of the
	signatures. Now we need to distinguish between signing the
	message and signing the message plus the surrounding
	signatures. This is the point of this flag. If set, it means:
	I sign all of the data starting at the next packet. */
	byte last;
	} PKT_onepass_sig;


	/* A v4 OpenPGP signature has a hashed and unhashed area containing
	co-called signature subpackets (RFC 4880, Section 5.2.3). These
	areas are described by this data structure. Use enum_sig_subpkt to
	parse this area. */
	typedef struct {
	size_t size; /* allocated */
	size_t len; /* used (serialized) */
	byte data[1]; /* the serialized subpackes (serialized) */
	} subpktarea_t;

	/* The in-memory representation of a designated revoker signature
	subpacket (RFC 4880, Section 5.2.3.15). */
	struct revocation_key {
	/* A bit field. 0x80 must be set. 0x40 means this information is
	sensitive (and should not be uploaded to a keyserver by
	default). */
	byte class;
	/* The public-key algorithm ID. */
	byte algid;
	/* The fingerprint of the authorized key. */
	byte fpr[MAX_FINGERPRINT_LEN];
	};


	/* Object to keep information about a PKA DNS record. */
	typedef struct
	{
	int valid; /* An actual PKA record exists for EMAIL. */
	int checked; /* Set to true if the FPR has been checked against the
	actual key. */
	char uri; / Malloced string with the URI. NULL if the URI is
	not available.*/
	unsigned char fpr[20]; /* The fingerprint as stored in the PKA RR. */
	char email[1];/* The email address from the notation data. */
	} pka_info_t;


	/* A signature packet (RFC 4880, Section 5.2). Only a subset of these
	fields are directly serialized (these are marked as such); the rest
	are read from the subpackets, which are not synthesized when
	serializing this data structure (i.e., when using build_packet()).
	Instead, the subpackets must be created by hand. */
	typedef struct
	{
	struct
	{
	unsigned checked:1; /* Signature has been checked. */
	unsigned valid:1; /* Signature is good (if checked is set). */
	unsigned chosen_selfsig:1; /* A selfsig that is the chosen one. */
	unsigned unknown_critical:1;
	unsigned exportable:1;
	unsigned revocable:1;
	unsigned policy_url:1; /* At least one policy URL is present */
	unsigned notation:1; /* At least one notation is present */
	unsigned pref_ks:1; /* At least one preferred keyserver is present */
	unsigned key_block:1; /* A key block subpacket is present. */
	unsigned expired:1;
	unsigned pka_tried:1; /* Set if we tried to retrieve the PKA record. */
	} flags;
	/* The key that allegedly generated this signature. (Directly
	serialized in v3 sigs; for v4 sigs, this must be explicitly added
	as an issuer subpacket (5.2.3.5.) */
	u32 keyid[2];
	/* When the signature was made (seconds since the Epoch). (Directly
	serialized in v3 sigs; for v4 sigs, this must be explicitly added
	as a signature creation time subpacket (5.2.3.4).) */
	u32 timestamp;
	u32 expiredate; /* Expires at this date or 0 if not at all. */
	/* The serialization format used / to use. If 0, then defaults to
	version 3. (Serialized.) */
	byte version;
	/* The signature type. (See RFC 4880, Section 5.2.1.) */
	byte sig_class;
	/* Algorithm used for public key scheme (e.g., PUBKEY_ALGO_RSA).
	(Serialized.) */
	byte pubkey_algo;
	/* Algorithm used for digest (e.g., DIGEST_ALGO_SHA1).
	(Serialized.) */
	byte digest_algo;
	byte trust_depth;
	byte trust_value;
	const byte *trust_regexp;
	struct revocation_key *revkey;
	int numrevkeys;
	int help_counter; /* Used internally bu some fucntions. */
	pka_info_t pka_info; / Malloced PKA data or NULL if not
	available. See also flags.pka_tried. */
	char signers_uid; / Malloced value of the SIGNERS_UID
	* subpacket or NULL. This string has
	* already been sanitized. */
	subpktarea_t hashed; / All subpackets with hashed data (v4 only). */
	subpktarea_t unhashed; / Ditto for unhashed data. */
	/* First 2 bytes of the digest. (Serialized. Note: this is not
	automatically filled in when serializing a signature!) */
	byte digest_start[2];
	/* The signature. (Serialized.) */
	gcry_mpi_t data[PUBKEY_MAX_NSIG];
	/* The message digest and its length (in bytes). Note the maximum
	digest length is 512 bits (64 bytes). If DIGEST_LEN is 0, then
	the digest's value has not been saved here. */
	byte digest[512 / 8];
	int digest_len;
	} PKT_signature;

	#define ATTRIB_IMAGE 1

	/* This is the cooked form of attributes. */
	struct user_attribute {
	byte type;
	const byte *data;
	u32 len;
	};


	/* A user id (RFC 4880, Section 5.11) or a user attribute packet (RFC
	4880, Section 5.12). Only a subset of these fields are directly
	serialized (these are marked as such); the rest are read from the
	self-signatures in merge_keys_and_selfsig()). */
	typedef struct
	{
	int ref; /* reference counter */
	/* The length of NAME. */
	int len;
	struct user_attribute *attribs;
	int numattribs;
	/* If this is not NULL, the packet is a user attribute rather than a
	user id (See RFC 4880 5.12). (Serialized.) */
	byte *attrib_data;
	/* The length of ATTRIB_DATA. */
	unsigned long attrib_len;
	byte *namehash;
	int help_key_usage;
	u32 help_key_expire;
	int help_full_count;
	int help_marginal_count;
	u32 expiredate; /* expires at this date or 0 if not at all */
	prefitem_t prefs; / list of preferences (may be NULL)*/
	u32 created; /* according to the self-signature */
	u32 keyupdate; /* From the ring trust packet. */
	char updateurl; / NULL or the URL of the last update origin. */
	byte keyorg; /* From the ring trust packet. */
	byte selfsigversion;
	struct
	{
	unsigned int mdc:1;
	unsigned int aead:1;
	unsigned int ks_modify:1;
	unsigned int compacted:1;
	unsigned int primary:2; /* 2 if set via the primary flag, 1 if calculated */
	unsigned int revoked:1;
	unsigned int expired:1;
	} flags;

	char mbox; / NULL or the result of mailbox_from_userid. */

	/* The text contained in the user id packet, which is normally the
	* name and email address of the key holder (See RFC 4880 5.11).
	* (Serialized.). For convenience an extra Nul is always appended. */
	char name[1];
	} PKT_user_id;



	struct revoke_info
	{
	/* revoked at this date */
	u32 date;
	/* the keyid of the revoking key (selfsig or designated revoker) */
	u32 keyid[2];
	/* the algo of the revoking key */
	byte algo;
	};


	/* Information pertaining to secret keys. */
	struct seckey_info
	{
	int is_protected:1; /* The secret info is protected and must */
	/* be decrypted before use, the protected */
	/* MPIs are simply (void) pointers to memory /
	/* and should never be passed to a mpi_xxx() */
	int sha1chk:1; /* SHA1 is used instead of a 16 bit checksum */
	u16 csum; /* Checksum for old protection modes. */
	byte algo; /* Cipher used to protect the secret information. */
	STRING2KEY s2k; /* S2K parameter. */
	byte ivlen; /* Used length of the IV. */
	byte iv[16]; /* Initialization vector for CFB mode. */
	};


	/****************
	* The in-memory representation of a public key (RFC 4880, Section
	* 5.5). Note: this structure contains significantly more information
	* than is contained in an OpenPGP public key packet. This
	* information is derived from the self-signed signatures (by
	* merge_keys_and_selfsig()) and is ignored when serializing the
	* packet. The fields that are actually written out when serializing
	* this packet are marked as accordingly.
	*
	* We assume that secret keys have the same number of parameters as
	* the public key and that the public parameters are the first items
	* in the PKEY array. Thus NPKEY is always less than NSKEY and it is
	* possible to compare the secret and public keys by comparing the
	* first NPKEY elements of the PKEY array. Note that since GnuPG 2.1
	* we don't use secret keys anymore directly because they are managed
	* by gpg-agent. However for parsing OpenPGP key files we need a way
	* to temporary store those secret keys. We do this by putting them
	* into the public key structure and extending the PKEY field to NSKEY
	* elements; the extra secret key information are stored in the
	* SECKEY_INFO field.
	*/
	typedef struct
	{
	/* When the key was created. (Serialized.) */
	u32 timestamp;
	u32 expiredate; /* expires at this date or 0 if not at all */
	u32 max_expiredate; /* must not expire past this date */
	struct revoke_info revoked;
	/* An OpenPGP packet consists of a header and a body. This is the
	size of the header. If this is 0, an appropriate size is
	automatically chosen based on the size of the body.
	(Serialized.) */
	byte hdrbytes;
	/* The serialization format. If 0, the default version (4) is used
	when serializing. (Serialized.) */
	byte version;
	byte selfsigversion; /* highest version of all of the self-sigs */
	/* The public key algorithm. (Serialized.) */
	byte pubkey_algo;
	byte pubkey_usage; /* for now only used to pass it to getkey() */
	byte req_usage; /* hack to pass a request to getkey() */
	u32 has_expired; /* set to the expiration date if expired */
	/* keyid of the primary key. Never access this value directly.
	Instead, use pk_main_keyid(). */
	u32 main_keyid[2];
	/* keyid of this key. Never access this value directly! Instead,
	use pk_keyid(). */
	u32 keyid[2];
	prefitem_t prefs; / list of preferences (may be NULL) */
	struct
	{
	unsigned int mdc:1; /* MDC feature set. */
	unsigned int aead:1; /* AEAD feature set. */
	unsigned int disabled_valid:1;/* The next flag is valid. */
	unsigned int disabled:1; /* The key has been disabled. */
	unsigned int primary:1; /* This is a primary key. */
	unsigned int revoked:2; /* Key has been revoked.
	1 = revoked by the owner
	2 = revoked by designated revoker. */
	unsigned int maybe_revoked:1; /* A designated revocation is
	present, but without the key to
	check it. */
	unsigned int valid:1; /* Key (especially subkey) is valid. */
	unsigned int dont_cache:1; /* Do not cache this key. */
	unsigned int backsig:2; /* 0=none, 1=bad, 2=good. */
	unsigned int serialno_valid:1;/* SERIALNO below is valid. */
	unsigned int exact:1; /* Found via exact (!) search. */
	} flags;
	PKT_user_id user_id; / If != NULL: found by that uid. */
	struct revocation_key *revkey;
	int numrevkeys;
	u32 trust_timestamp;
	byte trust_depth;
	byte trust_value;
	byte keyorg; /* From the ring trust packet. */
	u32 keyupdate; /* From the ring trust packet. */
	char updateurl; / NULL or the URL of the last update origin. */
	const byte *trust_regexp;
	char serialno; / Malloced hex string or NULL if it is
	likely not on a card. See also
	flags.serialno_valid. */
	/* If not NULL this malloced structure describes a secret key.
	(Serialized.) */
	struct seckey_info *seckey_info;
	/* The public key. Contains pubkey_get_npkey (pubkey_algo) +
	pubkey_get_nskey (pubkey_algo) MPIs. (If pubkey_get_npkey
	returns 0, then the algorithm is not understood and the PKEY
	contains a single opaque MPI.) (Serialized.) */
	gcry_mpi_t pkey[PUBKEY_MAX_NSKEY]; /* Right, NSKEY elements. */
	} PKT_public_key;

	/* Evaluates as true if the pk is disabled, and false if it isn't. If
	there is no disable value cached, fill one in. */
	#define pk_is_disabled(a) \
	(((a)->flags.disabled_valid)? \
	((a)->flags.disabled):(cache_disabled_value(ctrl,(a))))


	typedef struct {
	int len; /* length of data */
	char data[1];
	} PKT_comment;

	/* A compression packet (RFC 4880, Section 5.6). */
	typedef struct {
	/* Not used. */
	u32 len;
	/* Whether the serialized version of the packet used / should use
	the new format. */
	byte new_ctb;
	/* The compression algorithm. */
	byte algorithm;
	/* An iobuf holding the data to be decompressed. (This is not used
	for compression!) */
	iobuf_t buf;
	} PKT_compressed;

	/* A symmetrically encrypted data packet (RFC 4880, Section 5.7) or a
	symmetrically encrypted integrity protected data packet (Section
	5.13) */
	typedef struct {
	/* Remaining length of encrypted data. */
	u32 len;
	/* When encrypting in CFB mode, the first block size bytes of data
	* are random data and the following 2 bytes are copies of the last
	* two bytes of the random data (RFC 4880, Section 5.7). This
	* provides a simple check that the key is correct. EXTRALEN is the
	* size of this extra data or, in AEAD mode, the length of the
	* headers and the tags. This is used by build_packet when writing
	* out the packet's header. */
	int extralen;
	/* Whether the serialized version of the packet used / should use
	the new format. */
	byte new_ctb;
	/* Whether the packet has an indeterminate length (old format) or
	was encoded using partial body length headers (new format).
	Note: this is ignored when encrypting. */
	byte is_partial;
	/* If 0, MDC is disabled. Otherwise, the MDC method that was used
	(currently, only DIGEST_ALGO_SHA1 is supported). */
	byte mdc_method;
	/* If 0, AEAD is not used. Otherwise, the used AEAD algorithm.
	* MDC_METHOD (above) shall be zero if AEAD is used. */
	byte aead_algo;
	/* The cipher algo for/from the AEAD packet. 0 for other encryption
	* packets. */
	byte cipher_algo;
	/* The chunk byte from the AEAD packet. */
	byte chunkbyte;

	/* An iobuf holding the data to be decrypted. (This is not used for
	encryption!) */
	iobuf_t buf;
	} PKT_encrypted;

	typedef struct {
	byte hash[20];
	} PKT_mdc;


	/* Subtypes for the ring trust packet. */
	#define RING_TRUST_SIG 0 /* The classical signature cache. */
	#define RING_TRUST_KEY 1 /* A KEYORG on a primary key. */
	#define RING_TRUST_UID 2 /* A KEYORG on a user id. */

	/* The local only ring trust packet which OpenPGP declares as
	* implementation defined. GnuPG uses this to cache signature
	* verification status and since 2.1.18 also to convey information
	* about the origin of a key. Note that this packet is not part
	* struct packet_struct because we use it only local in the packet
	* parser and builder. */
	typedef struct {
	unsigned int trustval;
	unsigned int sigcache;
	unsigned char subtype; /* The subtype of this ring trust packet. */
	unsigned char keyorg; /* The origin of the key (KEYORG_). /
	u32 keyupdate; /* The wall time the key was last updated. */
	char url; / NULL or the URL of the source. */
	} PKT_ring_trust;


	/* A plaintext packet (see RFC 4880, 5.9). */
	typedef struct {
	/* The length of data in BUF or 0 if unknown. */
	u32 len;
	/* A buffer containing the data stored in the packet's body. */
	iobuf_t buf;
	byte new_ctb;
	byte is_partial; /* partial length encoded */
	/* The data's formatting. This is either 'b', 't', 'u', 'l' or '1'
	(however, the last two are deprecated). */
	int mode;
	u32 timestamp;
	/* The name of the file. This can be at most 255 characters long,
	since namelen is just a byte in the serialized format. */
	int namelen;
	char name[1];
	} PKT_plaintext;

	typedef struct {
	int control;
	size_t datalen;
	char data[1];
	} PKT_gpg_control;

	/* combine all packets into a union */
	struct packet_struct {
	pkttype_t pkttype;
	union {
	void *generic;
	PKT_symkey_enc symkey_enc; / PKT_SYMKEY_ENC */
	PKT_pubkey_enc pubkey_enc; / PKT_PUBKEY_ENC */
	PKT_onepass_sig onepass_sig; / PKT_ONEPASS_SIG */
	PKT_signature signature; / PKT_SIGNATURE */
	PKT_public_key public_key; / PKT_PUBLIC_[SUB]KEY */
	PKT_public_key secret_key; / PKT_SECRET_[SUB]KEY */
	PKT_comment comment; / PKT_COMMENT */
	PKT_user_id user_id; / PKT_USER_ID */
	PKT_compressed compressed; / PKT_COMPRESSED */
	PKT_encrypted encrypted; / PKT_ENCRYPTED[_MDC] */
	PKT_mdc mdc; / PKT_MDC */
	PKT_plaintext plaintext; / PKT_PLAINTEXT */
	PKT_gpg_control gpg_control; / PKT_GPG_CONTROL */
	} pkt;
	};

	#define init_packet(a) do { (a)->pkttype = 0; \
	(a)->pkt.generic = NULL; \
	} while(0)


	/* A notation. See RFC 4880, Section 5.2.3.16. */
	struct notation
	{
	/* The notation's name. */
	char *name;
	/* If the notation is human readable, then the value is stored here
	as a NUL-terminated string. If it is not human readable a human
	readable approximation of the binary value _may_ be stored
	here. */
	char *value;
	/* Sometimes we want to %-expand the value. In these cases, we save
	that transformed value here. */
	char *altvalue;
	/* If the notation is not human readable, then the value is stored
	here. */
	unsigned char *bdat;
	/* The amount of data stored in BDAT.

	Note: if this is 0 and BDAT is NULL, this does not necessarily
	mean that the value is human readable. It could be that we have
	a 0-length value. To determine whether the notation is human
	readable, always check if VALUE is not NULL. This works, because
	if a human-readable value has a length of 0, we will still
	allocate space for the NUL byte. */
	size_t blen;
	struct
	{
	/* The notation is critical. */
	unsigned int critical:1;
	/* The notation is human readable. */
	unsigned int human:1;
	/* The notation should be deleted. */
	unsigned int ignore:1;
	} flags;

	/* A field to facilitate creating a list of notations. */
	struct notation *next;
	};
	typedef struct notation *notation_t;

	/-- mainproc.c --/
	void reset_literals_seen(void);
	int proc_packets (ctrl_t ctrl, void *ctx, iobuf_t a );
	int proc_signature_packets (ctrl_t ctrl, void *ctx, iobuf_t a,
	strlist_t signedfiles, const char *sigfile );
	int proc_signature_packets_by_fd (ctrl_t ctrl,
	void *anchor, IOBUF a, int signed_data_fd );
	int proc_encryption_packets (ctrl_t ctrl, void *ctx, iobuf_t a);
	int list_packets( iobuf_t a );

	const byte issuer_fpr_raw (PKT_signature sig, size_t *r_len);
	char issuer_fpr_string (PKT_signature sig);

	/-- parse-packet.c --/


	void register_known_notation (const char *string);

	/* Sets the packet list mode to MODE (i.e., whether we are dumping a
	packet or not). Returns the current mode. This allows for
	temporarily suspending dumping by doing the following:

	int saved_mode = set_packet_list_mode (0);
	...
	set_packet_list_mode (saved_mode);
	*/
	int set_packet_list_mode( int mode );


	/* A context used with parse_packet. */
	struct parse_packet_ctx_s
	{
	iobuf_t inp; /* The input stream with the packets. */
	struct packet_struct last_pkt; /* The last parsed packet. */
	int free_last_pkt; /* Indicates that LAST_PKT must be freed. */
	int skip_meta; /* Skip ring trust packets. */
	unsigned int n_parsed_packets; /* Number of parsed packets. */
	};
	typedef struct parse_packet_ctx_s *parse_packet_ctx_t;

	#define init_parse_packet(a,i) do { \
	(a)->inp = (i); \
	(a)->last_pkt.pkttype = 0; \
	(a)->last_pkt.pkt.generic= NULL;\
	(a)->free_last_pkt = 0; \
	(a)->skip_meta = 0; \
	(a)->n_parsed_packets = 0; \
	} while (0)

	#define deinit_parse_packet(a) do { \
	if ((a)->free_last_pkt) \
	free_packet (NULL, (a)); \
	} while (0)


	#if DEBUG_PARSE_PACKET
	/* There are debug functions and should not be used directly. */
	int dbg_search_packet (parse_packet_ctx_t ctx, PACKET *pkt,
	off_t *retpos, int with_uid,
	const char* file, int lineno );
	int dbg_parse_packet (parse_packet_ctx_t ctx, PACKET *ret_pkt,
	const char *file, int lineno);
	int dbg_copy_all_packets( iobuf_t inp, iobuf_t out,
	const char* file, int lineno );
	int dbg_copy_some_packets( iobuf_t inp, iobuf_t out, off_t stopoff,
	const char* file, int lineno );
	int dbg_skip_some_packets( iobuf_t inp, unsigned n,
	const char* file, int lineno );
	#define search_packet( a,b,c,d ) \
	dbg_search_packet( (a), (b), (c), (d), __FILE__, __LINE__ )
	#define parse_packet( a, b ) \
	dbg_parse_packet( (a), (b), __FILE__, __LINE__ )
	#define copy_all_packets( a,b ) \
	dbg_copy_all_packets((a),(b), __FILE__, __LINE__ )
	#define copy_some_packets( a,b,c ) \
	dbg_copy_some_packets((a),(b),(c), __FILE__, __LINE__ )
	#define skip_some_packets( a,b ) \
	dbg_skip_some_packets((a),(b), __FILE__, __LINE__ )
	#else
	/* Return the next valid OpenPGP packet in *PKT. (This function will
	* skip any packets whose type is 0.) CTX must have been setup prior to
	* calling this function.
	*
	* Returns 0 on success, -1 if EOF is reached, and an error code
	* otherwise. In the case of an error, the packet in *PKT may be
	* partially constructed. As such, even if there is an error, it is
	* necessary to free *PKT to avoid a resource leak. To detect what
	* has been allocated, clear PKT before calling this function. /
	int parse_packet (parse_packet_ctx_t ctx, PACKET *pkt);

	/* Return the first OpenPGP packet in *PKT that contains a key (either
	* a public subkey, a public key, a secret subkey or a secret key) or,
	* if WITH_UID is set, a user id.
	*
	* Saves the position in the pipeline of the start of the returned
	* packet (according to iobuf_tell) in RETPOS, if it is not NULL.
	*
	* The return semantics are the same as parse_packet. */
	int search_packet (parse_packet_ctx_t ctx, PACKET *pkt,
	off_t *retpos, int with_uid);

	/* Copy all packets (except invalid packets, i.e., those with a type
	* of 0) from INP to OUT until either an error occurs or EOF is
	* reached.
	*
	* Returns -1 when end of file is reached or an error code, if an
	* error occurred. (Note: this function never returns 0, because it
	* effectively keeps going until it gets an EOF.) */
	int copy_all_packets (iobuf_t inp, iobuf_t out );

	/* Like copy_all_packets, but stops at the first packet that starts at
	* or after STOPOFF (as indicated by iobuf_tell).
	*
	* Example: if STOPOFF is 100, the first packet in INP goes from
	* 0 to 110 and the next packet starts at offset 111, then the packet
	* starting at offset 0 will be completely processed (even though it
	* extends beyond STOPOFF) and the packet starting at offset 111 will
	* not be processed at all. */
	int copy_some_packets (iobuf_t inp, iobuf_t out, off_t stopoff);

	/* Skips the next N packets from INP.
	*
	* If parsing a packet returns an error code, then the function stops
	* immediately and returns the error code. Note: in the case of an
	* error, this function does not indicate how many packets were
	* successfully processed. */
	int skip_some_packets (iobuf_t inp, unsigned int n);
	#endif

	/* Parse a signature packet and store it in *SIG.

	The signature packet is read from INP. The OpenPGP header (the tag
	and the packet's length) have already been read; the next byte read
	from INP should be the first byte of the packet's contents. The
	packet's type (as extract from the tag) must be passed as PKTTYPE
	and the packet's length must be passed as PKTLEN. This is used as
	the upper bound on the amount of data read from INP. If the packet
	is shorter than PKTLEN, the data at the end will be silently
	skipped. If an error occurs, an error code will be returned. -1
	means the EOF was encountered. 0 means parsing was successful. */
	int parse_signature( iobuf_t inp, int pkttype, unsigned long pktlen,
	PKT_signature *sig );

	/* Given a subpacket area (typically either PKT_signature.hashed or
	PKT_signature.unhashed), either:

	- test whether there are any subpackets with the critical bit set
	that we don't understand,

	- list the subpackets, or,

	- find a subpacket with a specific type.

	REQTYPE indicates the type of operation.

	If REQTYPE is SIGSUBPKT_TEST_CRITICAL, then this function checks
	whether there are any subpackets that have the critical bit and
	which GnuPG cannot handle. If GnuPG understands all subpackets
	whose critical bit is set, then this function returns simply
	returns SUBPKTS. If there is a subpacket whose critical bit is set
	and which GnuPG does not understand, then this function returns
	NULL and, if START is not NULL, sets *START to the 1-based index of
	the subpacket that violates the constraint.

	If REQTYPE is SIGSUBPKT_LIST_HASHED or SIGSUBPKT_LIST_UNHASHED, the
	packets are dumped. Note: if REQTYPE is SIGSUBPKT_LIST_HASHED,
	this function does not check whether the hash is correct; this is
	merely an indication of the section that the subpackets came from.

	If REQTYPE is anything else, then this function interprets the
	values as a subpacket type and looks for the first subpacket with
	that type. If such a packet is found, *CRITICAL (if not NULL) is
	set if the critical bit was set, *RET_N is set to the offset of the
	subpacket's content within the SUBPKTS buffer, *START is set to the
	1-based index of the subpacket within the buffer, and returns
	&SUBPKTS[*RET_N].

	*START is the number of initial subpackets to not consider. Thus,
	if START is 2, then the first 2 subpackets are ignored. /
	const byte enum_sig_subpkt ( const subpktarea_t subpkts,
	sigsubpkttype_t reqtype,
	size_t ret_n, int start, int *critical );

	/* Shorthand for:

	enum_sig_subpkt (buffer, reqtype, ret_n, NULL, NULL); */
	const byte parse_sig_subpkt ( const subpktarea_t buffer,
	sigsubpkttype_t reqtype,
	size_t *ret_n );

	/* This calls parse_sig_subpkt first on the hashed signature area in
	SIG and then, if that returns NULL, calls parse_sig_subpkt on the
	unhashed subpacket area in SIG. */
	const byte parse_sig_subpkt2 ( PKT_signature sig,
	sigsubpkttype_t reqtype);

	/* Returns whether the N byte large buffer BUFFER is sufficient to
	hold a subpacket of type TYPE. Note: the buffer refers to the
	contents of the subpacket (not the header) and it must already be
	initialized: for some subpackets, it checks some internal
	constraints.

	Returns 0 if the size is acceptable. Returns -2 if the buffer is
	definitely too short. To check for an error, check whether the
	return value is less than 0. */
	int parse_one_sig_subpkt( const byte *buffer, size_t n, int type );

	/* Looks for revocation key subpackets (see RFC 4880 5.2.3.15) in the
	hashed area of the signature packet. Any that are found are added
	to SIG->REVKEY and SIG->NUMREVKEYS is updated appropriately. */
	void parse_revkeys(PKT_signature *sig);

	/* Extract the attributes from the buffer at UID->ATTRIB_DATA and
	update UID->ATTRIBS and UID->NUMATTRIBS accordingly. */
	int parse_attribute_subpkts(PKT_user_id *uid);

	/* Set the UID->NAME field according to the attributes. MAX_NAMELEN
	must be at least 71. */
	void make_attribute_uidname(PKT_user_id *uid, size_t max_namelen);

	/* Allocate and initialize a new GPG control packet. DATA is the data
	to save in the packet. */
	PACKET *create_gpg_control ( ctrlpkttype_t type,
	const byte *data,
	size_t datalen );

	/-- build-packet.c --/
	int build_packet (iobuf_t out, PACKET *pkt);
	gpg_error_t build_packet_and_meta (iobuf_t out, PACKET *pkt);
	gpg_error_t gpg_mpi_write (iobuf_t out, gcry_mpi_t a);
	gpg_error_t gpg_mpi_write_nohdr (iobuf_t out, gcry_mpi_t a);
	u32 calc_packet_length( PACKET *pkt );
	void build_sig_subpkt( PKT_signature *sig, sigsubpkttype_t type,
	const byte *buffer, size_t buflen );
	void build_sig_subpkt_from_sig (PKT_signature sig, PKT_public_key pksk);
	int delete_sig_subpkt(subpktarea_t *buffer, sigsubpkttype_t type );
	void build_attribute_subpkt(PKT_user_id *uid,byte type,
	const void *buf,u32 buflen,
	const void *header,u32 headerlen);
	struct notation string_to_notation(const char string,int is_utf8);
	struct notation blob_to_notation(const char name,
	const char *data, size_t len);
	struct notation sig_to_notation(PKT_signature sig);
	void free_notation(struct notation *notation);

	/-- free-packet.c --/
	void free_symkey_enc( PKT_symkey_enc *enc );
	void free_pubkey_enc( PKT_pubkey_enc *enc );
	void free_seckey_enc( PKT_signature *enc );
	void release_public_key_parts( PKT_public_key *pk );
	void free_public_key( PKT_public_key *key );
	void free_attributes(PKT_user_id *uid);
	void free_user_id( PKT_user_id *uid );
	void free_comment( PKT_comment *rem );
	void free_packet (PACKET *pkt, parse_packet_ctx_t parsectx);
	prefitem_t copy_prefs (const prefitem_t prefs);
	PKT_public_key copy_public_key( PKT_public_key d, PKT_public_key *s );
	PKT_signature copy_signature( PKT_signature d, PKT_signature *s );
	PKT_user_id scopy_user_id (PKT_user_id sd );
	int cmp_public_keys( PKT_public_key a, PKT_public_key b );
	int cmp_signatures( PKT_signature a, PKT_signature b );
	int cmp_user_ids( PKT_user_id a, PKT_user_id b );


	/-- sig-check.c --/
	/* Check a signature. This is shorthand for check_signature2 with
	the unnamed arguments passed as NULL. */
	int check_signature (ctrl_t ctrl, PKT_signature *sig, gcry_md_hd_t digest);

	/* Check a signature. Looks up the public key from the key db. (If
	* R_PK is not NULL, it is stored at RET_PK.) DIGEST contains a
	* valid hash context that already includes the signed data. This
	* function adds the relevant meta-data to the hash before finalizing
	* it and verifying the signature. FOCRED_PK is usually NULL. */
	gpg_error_t check_signature2 (ctrl_t ctrl,
	PKT_signature *sig, gcry_md_hd_t digest,
	PKT_public_key *forced_pk,
	u32 r_expiredate, int r_expired, int *r_revoked,
	PKT_public_key **r_pk);


	/-- pubkey-enc.c --/
	gpg_error_t get_session_key (ctrl_t ctrl, PKT_pubkey_enc k, DEK dek);
	gpg_error_t get_override_session_key (DEK dek, const char string);

	/-- compress.c --/
	int handle_compressed (ctrl_t ctrl, void ctx, PKT_compressed cd,
	int (callback)(iobuf_t, void ), void *passthru );

	/-- encr-data.c --/
	int decrypt_data (ctrl_t ctrl, void ctx, PKT_encrypted ed, DEK *dek );

	/-- plaintext.c --/
	gpg_error_t get_output_file (const byte *embedded_name, int embedded_namelen,
	iobuf_t data, char *fnamep, estream_t fpp);
	int handle_plaintext( PKT_plaintext pt, md_filter_context_t mfx,
	int nooutput, int clearsig );
	int ask_for_detached_datafile( gcry_md_hd_t md, gcry_md_hd_t md2,
	const char *inname, int textmode );

	/-- sign.c --/
	int make_keysig_packet (ctrl_t ctrl,
	PKT_signature *ret_sig, PKT_public_key pk,
	PKT_user_id uid, PKT_public_key subpk,
	PKT_public_key *pksk, int sigclass, int digest_algo,
	u32 timestamp, u32 duration,
	int (mksubpkt)(PKT_signature , void *),
	void *opaque,
	const char *cache_nonce);
	gpg_error_t update_keysig_packet (ctrl_t ctrl,
	PKT_signature **ret_sig,
	PKT_signature *orig_sig,
	PKT_public_key *pk,
	PKT_user_id *uid,
	PKT_public_key *subpk,
	PKT_public_key *pksk,
	int (mksubpkt)(PKT_signature , void *),
	void *opaque );

	/-- keygen.c --/
	PKT_user_id generate_user_id (kbnode_t keyblock, const char uidstr);

	#endif /G10_PACKET_H/

File Metadata

Mime Type: text/x-diff
Expires: Tue, Sep 16, 12:01 PM (1 d, 22 h)
Storage Engine: local-disk
Storage Format: Raw Data
Storage Handle: e9/5e/3e5d3c74b3bd44e98cb9ff274983

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions