No OneTemporary
Actions

Size

865 KB

Subscribers

None

View Options

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

	diff --git a/g10/delkey.c b/g10/delkey.c
	index 458c451e0..904f4c26e 100644
	--- a/g10/delkey.c
	+++ b/g10/delkey.c
	@@ -1,377 +1,385 @@
	/* delkey.c - delete keys
	* Copyright (C) 1998, 1999, 2000, 2001, 2002, 2004,
	* 2005, 2006 Free Software Foundation, Inc.
	* Copyright (C) 2014, 2019 Werner Koch
	*
	* This file is part of GnuPG.
	*
	* GnuPG is free software; you can redistribute it and/or modify
	* it under the terms of the GNU General Public License as published by
	* the Free Software Foundation; either version 3 of the License, or
	* (at your option) any later version.
	*
	* GnuPG is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with this program; if not, see <https://www.gnu.org/licenses/>.
	*/

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

	#include "gpg.h"
	#include "options.h"
	#include "packet.h"
	#include "../common/status.h"
	#include "../common/iobuf.h"
	#include "keydb.h"
	#include "../common/util.h"
	#include "main.h"
	#include "trustdb.h"
	#include "filter.h"
	#include "../common/ttyio.h"
	#include "../common/i18n.h"
	#include "../common/shareddefs.h"
	#include "call-agent.h"


	/****************
	* Delete a public or secret key from a keyring.
	* r_sec_avail will be set if a secret key is available and the public
	* key can't be deleted for that reason.
	*/
	static gpg_error_t
	do_delete_key (ctrl_t ctrl, const char *username, int secret, int force,
	int *r_sec_avail)
	{
	gpg_error_t err;
	kbnode_t keyblock = NULL;
	kbnode_t node, kbctx;
	kbnode_t targetnode;
	KEYDB_HANDLE hd;
	PKT_public_key *pk = NULL;
	u32 keyid[2];
	int okay=0;
	int yes;
	KEYDB_SEARCH_DESC desc;
	int exactmatch; /* True if key was found by fingerprint. */
	int thiskeyonly; /* 0 = false, 1 = is primary key, 2 = is a subkey. */

	*r_sec_avail = 0;

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

	/* Search the userid. */
	err = classify_user_id (username, &desc, 1);
	exactmatch = (desc.mode == KEYDB_SEARCH_MODE_FPR);
	thiskeyonly = desc.exact;
	+
	+ err = keydb_lock (hd);
	+ if (err)
	+ {
	+ keydb_release (hd);
	+ goto leave;
	+ }
	+
	if (!err)
	err = keydb_search (hd, &desc, 1, NULL);
	if (err)
	{
	log_error (_("key \"%s\" not found: %s\n"), username, gpg_strerror (err));
	write_status_text (STATUS_DELETE_PROBLEM, "1");
	goto leave;
	}

	/* Read the keyblock. */
	err = keydb_get_keyblock (hd, &keyblock);
	if (err)
	{
	log_error (_("error reading keyblock: %s\n"), gpg_strerror (err) );
	goto leave;
	}

	/* Get the keyid from the keyblock. */
	node = find_kbnode( keyblock, PKT_PUBLIC_KEY );
	if (!node)
	{
	log_error ("Oops; key not found anymore!\n");
	err = gpg_error (GPG_ERR_GENERAL);
	goto leave;
	}

	/* If an operation only on a subkey is requested, find that subkey
	* now. */
	if (thiskeyonly)
	{
	kbnode_t tmpnode;

	for (kbctx=NULL; (tmpnode = walk_kbnode (keyblock, &kbctx, 0)); )
	{
	if (!(tmpnode->pkt->pkttype == PKT_PUBLIC_KEY
	\|\| tmpnode->pkt->pkttype == PKT_PUBLIC_SUBKEY))
	continue;
	if (exact_subkey_match_p (&desc, tmpnode))
	break;
	}
	if (!tmpnode)
	{
	log_error ("Oops; requested subkey not found anymore!\n");
	err = gpg_error (GPG_ERR_GENERAL);
	goto leave;
	}
	/* Set NODE to this specific subkey or primary key. */
	thiskeyonly = node == tmpnode? 1 : 2;
	targetnode = tmpnode;
	}
	else
	targetnode = node;

	pk = targetnode->pkt->pkt.public_key;
	keyid_from_pk (pk, keyid);

	if (!secret && !force)
	{
	if (have_secret_key_with_kid (ctrl, keyid))
	{
	*r_sec_avail = 1;
	err = gpg_error (GPG_ERR_EOF);
	goto leave;
	}
	else
	err = 0;
	}

	if (secret && !have_secret_key_with_kid (ctrl, keyid))
	{
	err = gpg_error (GPG_ERR_NOT_FOUND);
	log_error (_("key \"%s\" not found\n"), username);
	write_status_text (STATUS_DELETE_PROBLEM, "1");
	goto leave;
	}


	if (opt.batch && exactmatch)
	{
	if (secret && opt.pinentry_mode == PINENTRY_MODE_LOOPBACK
	&& !opt.answer_yes)
	log_error(_("can't do this in batch mode without \"--yes\"\n"));
	else
	okay++;
	}
	else if (opt.batch && secret)
	{
	log_error(_("can't do this in batch mode\n"));
	log_info (_("(unless you specify the key by fingerprint)\n"));
	}
	else if (opt.batch && opt.answer_yes)
	okay++;
	else if (opt.batch)
	{
	log_error(_("can't do this in batch mode without \"--yes\"\n"));
	log_info (_("(unless you specify the key by fingerprint)\n"));
	}
	else
	{
	print_key_info (ctrl, NULL, 0, pk, secret);
	tty_printf ("\n");
	if (thiskeyonly == 1 && !secret)
	{
	/* We need to delete the entire public key despite the use
	* of the thiskeyonly request. */
	tty_printf (_("Note: The public primary key and all its subkeys"
	" will be deleted.\n"));
	}
	else if (thiskeyonly == 2 && !secret)
	{
	tty_printf (_("Note: Only the shown public subkey"
	" will be deleted.\n"));
	}
	if (thiskeyonly == 1 && secret)
	{
	tty_printf (_("Note: Only the secret part of the shown primary"
	" key will be deleted.\n"));
	}
	else if (thiskeyonly == 2 && secret)
	{
	tty_printf (_("Note: Only the secret part of the shown subkey"
	" will be deleted.\n"));
	}

	if (thiskeyonly)
	tty_printf ("\n");

	yes = cpr_get_answer_is_yes
	(secret? "delete_key.secret.okay": "delete_key.okay",
	_("Delete this key from the keyring? (y/N) "));

	if (!cpr_enabled() && secret && yes)
	{
	/* I think it is not required to check a passphrase; if the
	* user is so stupid as to let others access his secret
	* keyring (and has no backup) - it is up him to read some
	* very basic texts about security. */
	yes = cpr_get_answer_is_yes
	("delete_key.secret.okay",
	_("This is a secret key! - really delete? (y/N) "));
	}

	if (yes)
	okay++;
	}


	if (okay)
	{
	if (secret)
	{
	char *prompt;
	gpg_error_t firsterr = 0;
	char *hexgrip;

	setup_main_keyids (keyblock);
	for (kbctx=NULL; (node = walk_kbnode (keyblock, &kbctx, 0)); )
	{
	if (!(node->pkt->pkttype == PKT_PUBLIC_KEY
	\|\| node->pkt->pkttype == PKT_PUBLIC_SUBKEY))
	continue;

	if (thiskeyonly && targetnode != node)
	continue;

	if (!agent_probe_secret_key (NULL, node->pkt->pkt.public_key))
	continue; /* No secret key for that public (sub)key. */

	prompt = gpg_format_keydesc (ctrl,
	node->pkt->pkt.public_key,
	FORMAT_KEYDESC_DELKEY, 1);
	err = hexkeygrip_from_pk (node->pkt->pkt.public_key, &hexgrip);
	/* NB: We require --yes to advise the agent not to
	* request a confirmation. The rationale for this extra
	* pre-caution is that since 2.1 the secret key may also
	* be used for other protocols and thus deleting it from
	* the gpg would also delete the key for other tools. */
	if (!err && !opt.dry_run)
	err = agent_delete_key (NULL, hexgrip, prompt,
	opt.answer_yes);
	xfree (prompt);
	xfree (hexgrip);
	if (err)
	{
	if (gpg_err_code (err) == GPG_ERR_KEY_ON_CARD)
	write_status_text (STATUS_DELETE_PROBLEM, "1");
	log_error (_("deleting secret %s failed: %s\n"),
	(node->pkt->pkttype == PKT_PUBLIC_KEY
	? _("key"):_("subkey")),
	gpg_strerror (err));
	if (!firsterr)
	firsterr = err;
	if (gpg_err_code (err) == GPG_ERR_CANCELED
	\|\| gpg_err_code (err) == GPG_ERR_FULLY_CANCELED)
	{
	write_status_error ("delete_key.secret", err);
	break;
	}
	}

	}

	err = firsterr;
	if (firsterr)
	goto leave;
	}
	else if (thiskeyonly == 2)
	{
	/* Delete the specified public subkey. */
	for (kbctx=NULL; (node = walk_kbnode (keyblock, &kbctx, 0)); )
	if (targetnode == node)
	break;
	log_assert (node);
	delete_kbnode (node);
	while ((node = walk_kbnode (keyblock, &kbctx, 0))
	&& node->pkt->pkttype == PKT_SIGNATURE)
	delete_kbnode (node);

	commit_kbnode (&keyblock);
	err = keydb_update_keyblock (ctrl, hd, keyblock);
	if (err)
	{
	log_error (_("update failed: %s\n"), gpg_strerror (err));
	goto leave;
	}
	}
	else
	{
	err = keydb_delete_keyblock (hd);
	if (err)
	{
	log_error (_("deleting keyblock failed: %s\n"),
	gpg_strerror (err));
	goto leave;
	}
	}

	/* Note that the ownertrust being cleared will trigger a
	revalidation_mark(). This makes sense - only deleting keys
	that have ownertrust set should trigger this. */

	if (!secret && pk && !opt.dry_run && thiskeyonly != 2
	&& clear_ownertrusts (ctrl, pk))
	{
	if (opt.verbose)
	log_info (_("ownertrust information cleared\n"));
	}
	}

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


	/*
	* Delete a public or secret key from a keyring.
	*/
	gpg_error_t
	delete_keys (ctrl_t ctrl, strlist_t names, int secret, int allow_both)
	{
	gpg_error_t err;
	int avail;
	int force = (!allow_both && !secret && opt.expert);

	/* Force allows us to delete a public key even if a secret key
	exists. */

	for ( ;names ; names=names->next )
	{
	err = do_delete_key (ctrl, names->d, secret, force, &avail);
	if (err && avail)
	{
	if (allow_both)
	{
	err = do_delete_key (ctrl, names->d, 1, 0, &avail);
	if (!err)
	err = do_delete_key (ctrl, names->d, 0, 0, &avail);
	}
	else
	{
	log_error (_("there is a secret key for public key \"%s\"!\n"),
	names->d);
	log_info(_("use option \"--delete-secret-keys\" to delete"
	" it first.\n"));
	write_status_text (STATUS_DELETE_PROBLEM, "2");
	return err;
	}
	}

	if (err)
	{
	log_error ("%s: delete key failed: %s\n",
	names->d, gpg_strerror (err));
	return err;
	}
	}

	return 0;
	}
	diff --git a/g10/getkey.c b/g10/getkey.c
	index 6af6dc0a5..efb157645 100644
	--- a/g10/getkey.c
	+++ b/g10/getkey.c
	@@ -1,4752 +1,4755 @@
	/* 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, 2024 g10 Code GmbH
	*
	* This file is part of GnuPG.
	*
	* GnuPG is free software; you can redistribute it and/or modify
	* it under the terms of the GNU General Public License as published by
	* the Free Software Foundation; either version 3 of the License, or
	* (at your option) any later version.
	*
	* GnuPG is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with this program; if not, see <https://www.gnu.org/licenses/>.
	* SPDX-License-Identifier: GPL-3.0-or-later
	*/

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

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

	#define MAX_PK_CACHE_ENTRIES PK_UID_CACHE_SIZE
	#define MAX_UID_CACHE_ENTRIES PK_UID_CACHE_SIZE

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

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


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

	/* Allow returning an ADSK key. */
	int allow_adsk;

	/* 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. FWIW: the req_usage field in PKT_public_key
	used to be an u8 but meanwhile is an u16. */
	int req_usage;

	/* The database handle. */
	KEYDB_HANDLE kr_handle;

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

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

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

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

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

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


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

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

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


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


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

	if (pk_cache_disabled)
	return;

	if (pk->flags.dont_cache)
	return;

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

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

	if (pk_cache_entries >= MAX_PK_CACHE_ENTRIES)
	{
	int n;

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


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

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




	/* Disable and drop the public key cache (which is filled by
	cache_public_key and get_pubkey). Note: there is currently no way
	to re-enable this cache. */
	void
	getkey_disable_caches (void)
	{
	#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.
	* If R_KEYBLOCK is not NULL the entire keyblock is stored there if
	* found and FORCED_PK is not used; if not used or on error NULL is
	* stored there. Use this function only to find the key for
	* verification; it can't be used to select a key for signing. */
	gpg_error_t
	get_pubkey_for_sig (ctrl_t ctrl, PKT_public_key pk, PKT_signature sig,
	PKT_public_key forced_pk, kbnode_t r_keyblock)
	{
	gpg_error_t err;
	const byte *fpr;
	size_t fprlen;

	if (r_keyblock)
	*r_keyblock = NULL;

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

	/* Make sure to request only keys cabable of signing. This makes
	* sure that a subkey w/o a valid backsig or with bad usage flags
	* will be skipped. We also request the verification mode so that
	* expired and revoked keys are returned. We keep only a requested
	* CERT usage in PK for the sake of key signatures. */
	pk->req_usage = (PUBKEY_USAGE_SIG \| PUBKEY_USAGE_VERIFY
	\| (pk->req_usage & PUBKEY_USAGE_CERT));

	/* First try the ISSUER_FPR info. */
	fpr = issuer_fpr_raw (sig, &fprlen);
	if (fpr && !get_pubkey_byfpr (ctrl, pk, r_keyblock, fpr, fprlen))
	return 0;
	if (r_keyblock)
	{
	release_kbnode (*r_keyblock);
	*r_keyblock = NULL;
	}

	/* Fallback to use the ISSUER_KEYID. */
	err = get_pubkey_bykid (ctrl, pk, r_keyblock, sig->keyid);
	if (err && r_keyblock)
	{
	release_kbnode (*r_keyblock);
	*r_keyblock = NULL;
	}
	return err;
	}


	/* 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!
	*
	* If R_KEYBLOCK is not NULL, then the first result's keyblock is
	* returned in *R_KEYBLOCK. This should be freed using
	* release_kbnode().
	*
	* 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. */
	gpg_error_t
	get_pubkey_bykid (ctrl_t ctrl, PKT_public_key pk, kbnode_t r_keyblock,
	u32 *keyid)
	{
	int internal = 0;
	gpg_error_t rc = 0;

	if (r_keyblock)
	*r_keyblock = NULL;

	#if MAX_PK_CACHE_ENTRIES
	if (pk && !r_keyblock)
	{
	/* 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.
	* The old get_pubkey_function did not check PK->REQ_USAGE when
	* reading from the cache. This is probably a bug. Note that
	* the cache is not used when the caller asked to return the
	* entire keyblock. This is because the cache does not
	* associate the public key with its primary key. */
	pk_cache_entry_t ce;
	for (ce = pk_cache; ce; ce = ce->next)
	{
	if (ce->keyid[0] == keyid[0] && ce->keyid[1] == keyid[1])
	{
	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 (ctrl);
	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);
	if (!rc && r_keyblock)
	{
	*r_keyblock = kb;
	kb = NULL;
	}
	release_kbnode (kb);
	}

	if (rc) /* Return a more useful error code. */
	rc = gpg_error (GPG_ERR_NO_PUBKEY);

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


	/* Wrapper for get_pubkey_bykid w/o keyblock return feature. */
	int
	get_pubkey (ctrl_t ctrl, PKT_public_key pk, u32 keyid)
	{
	return get_pubkey_bykid (ctrl, pk, NULL, keyid);
	}


	/* Same as get_pubkey but if the key was not found the function tries
	* to import it from LDAP. FIXME: We should not need this but switch
	* to a fingerprint lookup. */
	gpg_error_t
	get_pubkey_with_ldap_fallback (ctrl_t ctrl, PKT_public_key pk, u32 keyid)
	{
	gpg_error_t err;

	err = get_pubkey (ctrl, pk, keyid);
	if (!err)
	return 0;

	if (gpg_err_code (err) != GPG_ERR_NO_PUBKEY)
	return err;

	/* Note that this code does not handle the case for two readers
	* having both openpgp encryption keys. Only one will be tried. */
	if (opt.debug)
	log_debug ("using LDAP to find a public key\n");
	err = keyserver_import_keyid (ctrl, keyid,
	opt.keyserver, KEYSERVER_IMPORT_FLAG_LDAP);
	if (gpg_err_code (err) == GPG_ERR_NO_DATA
	\|\| gpg_err_code (err) == GPG_ERR_NO_KEYSERVER)
	{
	/* Dirmngr returns NO DATA is the selected keyserver
	* does not have the requested key. It returns NO
	* KEYSERVER if no LDAP keyservers are configured. */
	err = gpg_error (GPG_ERR_NO_PUBKEY);
	}
	if (err)
	return err;

	return get_pubkey (ctrl, pk, keyid);
	}


	/* Similar to get_pubkey, but it does not take PK->REQ_USAGE into
	* account nor does it merge in the self-signed data. This function
	* also only considers primary keys. 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 (ctrl_t ctrl, 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 (ctrl);
	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 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_ext (ctrl_t ctrl, u32 * keyid, unsigned int flags)
	{
	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 (ctrl);
	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];
	ctx.allow_adsk = !!(flags & GET_PUBKEYBLOCK_FLAG_ADSK);
	rc = lookup (ctrl, &ctx, 0, &keyblock, NULL);
	getkey_end (ctrl, &ctx);

	return rc ? NULL : keyblock;
	}


	kbnode_t
	get_pubkeyblock (ctrl_t ctrl, u32 * keyid)
	{
	return get_pubkeyblock_ext (ctrl, keyid, 0);
	}

	/* 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 (ctrl);
	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)
	{
	if (!agent_probe_secret_key (/ctrl/NULL, pk))
	{
	release_public_key_parts (pk);
	err = gpg_error (GPG_ERR_NO_SECKEY);
	}
	}

	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 && !opt.ignore_expiration))
	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 && !opt.ignore_expiration))
	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).
	+ conduct the search is returned in *RET_KDBHD, holding the lock.
	+ This can be used to get subsequent results using keydb_search_next.
	+ Note: in this case, no advanced filtering is done for subsequent
	+ results (e.g., WANT_SECRET and PK->REQ_USAGE are not respected).

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

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

	if (!namelist)
	/* No search terms: iterate over the whole DB. */
	{
	ctx = xmalloc_clear (sizeof *ctx);
	ctx->nitems = 1;
	ctx->items[0].mode = KEYDB_SEARCH_MODE_FIRST;
	if (!include_unusable)
	{
	ctx->items[0].skipfnc = skip_unusable;
	ctx->items[0].skipfncvalue = ctrl;
	}
	}
	else
	{
	namelist_expanded = expand_group (namelist, 1);
	namelist = namelist_expanded;

	/* 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);
	rc = gpg_err_code (err); /* FIXME: remove gpg_err_code. */
	goto leave;
	}
	if (!include_unusable
	&& ctx->items[n].mode != KEYDB_SEARCH_MODE_SHORT_KID
	&& ctx->items[n].mode != KEYDB_SEARCH_MODE_LONG_KID
	&& ctx->items[n].mode != KEYDB_SEARCH_MODE_FPR)
	{
	ctx->items[n].skipfnc = skip_unusable;
	ctx->items[n].skipfncvalue = ctrl;
	}
	}
	}

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

	if (!ret_kb)
	ret_kb = &help_kb;

	+ if (ret_kdbhd)
	+ keydb_lock (ctx->kr_handle);
	+
	if (pk)
	{
	/* It is a bit tricky to allow returning an ADSK key: lookup
	* masks the req_usage flags using the standard usage maps and
	* only if ctx->allow_adsk is set, sets the RENC flag again. */
	ctx->req_usage = pk->req_usage;
	if ((pk->req_usage & PUBKEY_USAGE_RENC))
	ctx->allow_adsk = 1;
	}

	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. */
	{
	if (ctx->extra_list)
	{
	for (r=ctx->extra_list; r->next; r = r->next)
	;
	r->next = namelist_expanded;
	}
	else
	ctx->extra_list = namelist_expanded;
	namelist_expanded = NULL;
	*retctx = ctx;
	}
	else
	{
	if (ret_kdbhd)
	{
	*ret_kdbhd = ctx->kr_handle;
	ctx->kr_handle = NULL;
	}
	getkey_end (ctrl, ctx);
	}

	leave:
	free_strlist (namelist_expanded);
	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 functionality is
	* used and no local search is done.
	* GET_PUBKEY_TRY_LDAP - If the key was not found locally try LDAP.
	*
	* 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, is_fpr;
	KEYDB_SEARCH_DESC fprbuf;
	int nodefault = 0;
	int anylocalfirst = 0;
	int mechanism_type = AKL_NODEFAULT;
	struct akl *used_akl = opt.auto_key_locate;

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

	/* If we are called due to --locate-external-key check whether NAME
	* is a fingerprint and then try to lookup that key by configured
	* method which support lookup by fingerprint. FPRBUF carries the
	* parsed fingerprint iff IS_FPR is true. */
	is_fpr = 0;
	if (!is_mbox && (mode == GET_PUBKEY_NO_LOCAL \|\| mode == GET_PUBKEY_TRY_LDAP))
	{
	if (!classify_user_id (name, &fprbuf, 1)
	&& fprbuf.mode == KEYDB_SEARCH_MODE_FPR)
	is_fpr = 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)
	;
	else if (mode == GET_PUBKEY_TRY_LDAP)
	{
	static struct akl ldap_only_akl = { AKL_LDAP, NULL, NULL };

	used_akl = &ldap_only_akl;
	}
	else
	{
	/* auto-key-locate is enabled. */

	/* nodefault is true if "nodefault" or "local" appear. */
	for (akl = used_akl; 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 = used_akl; 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 \|\| is_fpr))
	{
	/* 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 = used_akl; 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)
	{
	/* Note that we get here in is_fpr more, so there is
	* no extra check for it required. */
	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:
	if (is_fpr)
	{
	mechanism_string = "";
	rc = GPG_ERR_NO_PUBKEY;
	}
	else
	{
	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:
	/* This is now obsolete. */
	break;

	case AKL_DANE:
	if (is_fpr)
	{
	mechanism_string = "";
	rc = GPG_ERR_NO_PUBKEY;
	break;
	}
	else
	{
	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:
	if (is_fpr)
	{
	mechanism_string = "";
	rc = GPG_ERR_NO_PUBKEY;
	}
	else
	{
	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:
	if (!keyserver_any_configured (ctrl))
	{
	mechanism_string = "";
	rc = GPG_ERR_NO_PUBKEY;
	}
	else
	{
	mechanism_string = is_fpr? "ldap/fpr":"ldap/mbox";
	glo_ctrl.in_auto_key_retrieve++;
	if (is_fpr)
	rc = keyserver_import_fpr (ctrl,
	fprbuf.u.fpr, fprbuf.fprlen,
	opt.keyserver,
	KEYSERVER_IMPORT_FLAG_LDAP);
	else
	rc = keyserver_import_mbox (ctrl, name, &fpr, &fpr_len,
	opt.keyserver,
	KEYSERVER_IMPORT_FLAG_LDAP);
	/* Map error codes because Dirmngr returns NO DATA
	* if the keyserver does not have the requested key.
	* It returns NO KEYSERVER if no LDAP keyservers are
	* configured. */
	if (gpg_err_code (rc) == GPG_ERR_NO_DATA
	\|\| gpg_err_code (rc) == GPG_ERR_NO_KEYSERVER)
	rc = gpg_error (GPG_ERR_NO_PUBKEY);
	glo_ctrl.in_auto_key_retrieve--;
	}
	break;

	case AKL_NTDS:
	mechanism_string = "NTDS";
	glo_ctrl.in_auto_key_retrieve++;
	if (is_fpr)
	rc = keyserver_import_fpr_ntds (ctrl,
	fprbuf.u.fpr, fprbuf.fprlen);
	else
	rc = keyserver_import_ntds (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++;
	if (is_fpr)
	{
	rc = keyserver_import_fpr (ctrl,
	fprbuf.u.fpr, fprbuf.fprlen,
	opt.keyserver,
	KEYSERVER_IMPORT_FLAG_LDAP);
	/* Map error codes because Dirmngr returns NO
	* DATA if the keyserver does not have the
	* requested key. It returns NO KEYSERVER if no
	* LDAP keyservers are configured. */
	if (gpg_err_code (rc) == GPG_ERR_NO_DATA
	\|\| gpg_err_code (rc) == GPG_ERR_NO_KEYSERVER)
	rc = gpg_error (GPG_ERR_NO_PUBKEY);
	}
	else
	{
	rc = keyserver_import_mbox (ctrl, name, &fpr, &fpr_len,
	opt.keyserver, 0);
	}
	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++;
	if (is_fpr)
	{
	rc = keyserver_import_fpr (ctrl,
	fprbuf.u.fpr, fprbuf.fprlen,
	opt.keyserver,
	KEYSERVER_IMPORT_FLAG_LDAP);
	if (gpg_err_code (rc) == GPG_ERR_NO_DATA
	\|\| gpg_err_code (rc) == GPG_ERR_NO_KEYSERVER)
	rc = gpg_error (GPG_ERR_NO_PUBKEY);
	}
	else
	{
	rc = keyserver_import_mbox (ctrl, name,
	&fpr, &fpr_len, keyserver, 0);
	}
	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, 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 \|\| is_fpr))
	{
	char fpr_string[MAX_FINGERPRINT_LEN * 2 + 1];

	if (is_fpr)
	{
	log_assert (fprbuf.fprlen <= MAX_FINGERPRINT_LEN);
	bin2hex (fprbuf.u.fpr, fprbuf.fprlen, fpr_string);
	}
	else
	{
	log_assert (fpr_len <= MAX_FINGERPRINT_LEN);
	bin2hex (fpr, fpr_len, fpr_string);
	}

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

	free_strlist (namelist);
	namelist = NULL;
	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)
	{
	GETKEY_CTX ctx = *retctx;
	strlist_t sl;

	if (ctx->extra_list)
	{
	for (sl=ctx->extra_list; sl->next; sl = sl->next)
	;
	sl->next = namelist;
	}
	else
	ctx->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 subkeys. 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;

	if ((new->key.pubkey_usage & PUBKEY_USAGE_ENC) == 0)
	new->creation_time = 0;
	else
	new->creation_time = new->key.timestamp;

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

	/* When new key has no encryption key, use OLD key. */
	if (new->creation_time == 0)
	return 1;

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

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

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

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

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

	if (new->validity != TRUST_EXPIRED && old->validity < new->validity)
	return -1; /* Validity of the NEW key is better. */
	if (old->validity == TRUST_EXPIRED && new->validity != TRUST_EXPIRED)
	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;
	PKT_public_key pk0;

	log_assert (ret_keyblock != NULL);

	if (retctx)
	*retctx = NULL;

	memset (&pk0, 0, sizeof pk0);
	pk0.req_usage = pk? pk->req_usage : 0;

	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. */
	{
	release_kbnode (*ret_keyblock);
	*ret_keyblock = NULL;
	getkey_end (ctrl, ctx);
	ctx = NULL;
	}
	err = get_pubkey_byname (ctrl, mode,
	&ctx, &pk0, 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)
	{
	u32 now = make_timestamp ();
	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 && pk0.keyorg == KEYORG_WKD
	&& (pk0.keyupdate + 3*3600) < now
	&& (pk0.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)
	{
	release_public_key_parts (&pk0);
	goto start_over;
	}
	}
	}

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

	copy_public_key (&new.key, &pk0);
	if (pubkey_cmp (ctrl, name, &best, &new, *ret_keyblock) >= 0)
	{
	release_public_key_parts (&new.key);
	free_user_id (new.uid);
	}
	else
	best = new;
	new.uid = NULL;

	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)
	{
	ctx = xtrycalloc (1, sizeof **retctx);
	if (! ctx)
	err = gpg_error_from_syserror ();
	else
	{
	ctx->kr_handle = keydb_new (ctrl);
	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];

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

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

	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. If R_KEYBLOCK is not NULL and a key was found the
	* keyblock is stored there; otherwiese NULL is stored there.
	*
	* 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,
	kbnode_t *r_keyblock)
	{
	gpg_error_t err;
	kbnode_t keyblock;
	kbnode_t found_key;
	unsigned int infoflags;

	if (r_keyblock)
	*r_keyblock = NULL;

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

	if (!err && r_keyblock)
	*r_keyblock = keyblock;
	else
	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 xmalloc, 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().
	*
	* FPR is a byte array whose contents is the fingerprint to use as
	* the search term. FPRLEN specifies the length of the
	* fingerprint (in bytes). Currently, only 16, 20, and 32-byte
	* fingerprints are supported.
	*
	* FIXME: We should replace this with the _byname function. This can
	* be done by creating a userID conforming to the unified fingerprint
	* style. */
	int
	get_pubkey_byfpr (ctrl_t ctrl, PKT_public_key pk, kbnode_t r_keyblock,
	const byte *fpr, size_t fprlen)
	{
	int rc;

	if (r_keyblock)
	*r_keyblock = NULL;

	if (fprlen == 32 \|\| fprlen == 20 \|\| fprlen == 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 (ctrl);
	if (!ctx.kr_handle)
	return gpg_error_from_syserror ();

	ctx.nitems = 1;
	ctx.items[0].mode = KEYDB_SEARCH_MODE_FPR;
	memcpy (ctx.items[0].u.fpr, fpr, fprlen);
	ctx.items[0].fprlen = fprlen;
	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_byfpr, 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_byfpr, PK may be NULL. In that case, this
	* function effectively just checks for the existence of the key. */
	gpg_error_t
	get_pubkey_byfpr_fast (ctrl_t ctrl, PKT_public_key * pk,
	const byte *fpr, size_t fprlen)
	{
	gpg_error_t err;
	KBNODE keyblock;

	err = get_keyblock_byfpr_fast (ctrl, &keyblock, NULL, 0, fpr, fprlen, 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_byfpr_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 one to do an
	* insert operation on a locked keydb handle. If PRIMARY_ONLY is set
	* the function returns a keyblock which has the requested fingerprint
	* has primary key. */
	gpg_error_t
	get_keyblock_byfpr_fast (ctrl_t ctrl,
	kbnode_t r_keyblock, KEYDB_HANDLE r_hd,
	int primary_only,
	const byte *fpr, size_t fprlen, int lock)
	{
	gpg_error_t err;
	KEYDB_HANDLE hd;
	kbnode_t keyblock;
	byte fprbuf[MAX_FINGERPRINT_LEN];
	int i;
	byte tmpfpr[MAX_FINGERPRINT_LEN];
	size_t tmpfprlen;

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

	for (i = 0; i < MAX_FINGERPRINT_LEN && i < fprlen; i++)
	fprbuf[i] = fpr[i];

	hd = keydb_new (ctrl);
	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);
	}

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

	again:
	err = keydb_search_fpr (hd, fprbuf, fprlen);
	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);

	if (primary_only)
	{
	fingerprint_from_pk (keyblock->pkt->pkt.public_key, tmpfpr, &tmpfprlen);
	if (fprlen != tmpfprlen \|\| memcmp (fpr, tmpfpr, fprlen))
	{
	release_kbnode (keyblock);
	keyblock = NULL;
	goto again;
	}
	}

	/* 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_t kb;
	kbnode_t node;
	int any_revoked, any_expired, any_disabled;

	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 (ctrl);
	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);

	any_revoked = any_expired = any_disabled = 0;
	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)
	{
	any_revoked = 1;
	if (DBG_LOOKUP)
	log_debug ("not using %s as default key, %s",
	keystr_from_pk (pk), "revoked");
	continue;
	}
	if (pk->has_expired)
	{
	any_expired = 1;
	if (DBG_LOOKUP)
	log_debug ("not using %s as default key, %s",
	keystr_from_pk (pk), "expired");
	continue;
	}
	if (pk_is_disabled (pk))
	{
	any_disabled = 1;
	if (DBG_LOOKUP)
	log_debug ("not using %s as default key, %s",
	keystr_from_pk (pk), "disabled");
	continue;
	}

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

	release_kbnode (kb);
	if (err)
	{
	if (! warned && ! opt.quiet)
	{
	gpg_err_code_t ec;

	/* Try to get a better error than no secret key if we
	* only know that the public key is not usable. */
	if (any_revoked)
	ec = GPG_ERR_CERT_REVOKED;
	else if (any_expired)
	ec = GPG_ERR_KEY_EXPIRED;
	else if (any_disabled)
	ec = GPG_ERR_KEY_DISABLED;
	else
	ec = GPG_ERR_NO_SECKEY;

	log_info (_("Warning: not using '%s' as default key: %s\n"),
	t->d, gpg_strerror (ec));
	print_reported_error (err, ec);
	}
	}
	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");
	}


	/* This function parses the key flags and returns PUBKEY_USAGE_ flags. */
	unsigned int
	parse_key_usage (PKT_signature * sig)
	{
	int key_usage = 0;
	const byte *p;
	size_t n;
	byte flags;

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

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

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

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

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

	if ((flags & 0x80))
	{
	key_usage \|= PUBKEY_USAGE_GROUP;
	flags &= ~0x80;
	}

	if (flags)
	key_usage \|= PUBKEY_USAGE_UNKNOWN;

	n--;
	p++;
	if (n)
	{
	flags = *p;
	if ((flags & 0x04))
	key_usage \|= PUBKEY_USAGE_RENC;
	if ((flags & 0x08))
	key_usage \|= PUBKEY_USAGE_TIME;
	}

	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:
	* - whether the UID has been revoked
	* - assumed creation date of the UID
	* - temporary store the keyflags here
	* - temporary store the key expiration time here
	* - mark whether the primary user ID flag hat been set.
	* - store the preferences
	*/
	static void
	fixup_uidnode (KBNODE uidnode, KBNODE signode, u32 keycreated)
	{
	PKT_user_id *uid = uidnode->pkt->pkt.user_id;
	PKT_signature *sig = signode->pkt->pkt.signature;
	const byte p, sym, aead, hash, *zip;
	size_t n, nsym, naead, nhash, nzip;

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

	uid->expiredate = sig->expiredate;

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

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

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

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

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

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

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

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

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

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


	/* Store the revocation signature into the RINFO struct. */
	static void
	sig_to_revoke_info (PKT_signature * sig, struct revoke_info *rinfo)
	{
	int reason_seq = 0;
	size_t reason_n;
	const byte *reason_p;

	rinfo->date = sig->timestamp;
	rinfo->algo = sig->pubkey_algo;
	rinfo->keyid[0] = sig->keyid[0];
	rinfo->keyid[1] = sig->keyid[1];
	xfree (rinfo->reason_comment);
	rinfo->reason_comment = NULL;
	rinfo->reason_comment_len = 0;
	rinfo->reason_code = 0;
	rinfo->got_reason = 0;

	while ((reason_p = enum_sig_subpkt (sig, 1, SIGSUBPKT_REVOC_REASON,
	&reason_n, &reason_seq, NULL))
	&& !reason_n)
	; /* Skip over empty reason packets. */

	if (reason_p)
	{
	rinfo->got_reason = 1;
	rinfo->reason_code = *reason_p;
	reason_n--; reason_p++;
	if (reason_n)
	{
	rinfo->reason_comment = xmalloc (reason_n);
	memcpy (rinfo->reason_comment, reason_p, reason_n);
	rinfo->reason_comment_len = reason_n;
	}
	}
	}


	/* 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
	* hard 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++, pk->numrevkeys++)
	{
	pk->revkey[pk->numrevkeys].class
	= sig->revkey[i].class;
	pk->revkey[pk->numrevkeys].algid
	= sig->revkey[i].algid;
	pk->revkey[pk->numrevkeys].fprlen
	= sig->revkey[i].fprlen;
	memcpy (pk->revkey[pk->numrevkeys].fpr,
	sig->revkey[i].fpr, sig->revkey[i].fprlen);
	memset (pk->revkey[pk->numrevkeys].fpr
	+ sig->revkey[i].fprlen,
	0,
	sizeof (sig->revkey[i].fpr)
	- sig->revkey[i].fprlen);
	}
	}

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

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

	}
	}
	}
	}
	}
	}

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

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

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

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

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

	/* SIGNODE is the 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, 1, SIGSUBPKT_KEY_EXPIRE, NULL);
	if (p && buf32_to_u32 (p))
	{
	key_expire = keytimestamp + buf32_to_u32 (p);
	key_expire_seen = 1;
	}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	ultimate_pk = xmalloc_clear (sizeof (*ultimate_pk));

	/* We don't want to use the full get_pubkey to avoid
	* infinite recursion in certain cases. There is no
	* reason to check that an ultimately trusted key is
	* still valid - if it has been revoked the user
	* should also remove the ultimate trust flag. */
	if (get_pubkey_fast (ctrl, 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)
	& PUBKEY_USAGE_BASIC_MASK);
	}
	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 \| PUBKEY_USAGE_GROUP);
	}

	/* 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 recent 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)
	& PUBKEY_USAGE_BASIC_MASK);
	}
	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 \| PUBKEY_USAGE_GROUP);
	}

	subpk->pubkey_usage = key_usage;

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

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

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

	subpk->flags.valid = 1;

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

	sigdate = 0;

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

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

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

	seq = 0;

	/* It is safe to have this in the unhashed area since the 0x19
	* is located on the selfsig for convenience, not security. */
	while ((p = enum_sig_subpkt (sig, 0, SIGSUBPKT_SIGNATURE,
	&n, &seq, NULL)))
	if (n > 3
	&& ((p[0] == 3 && p[2] == 0x19) \|\| (p[0] == 4 && p[1] == 0x19)
	\|\| (p[0] == 5 && 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 = { 0 };
	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)
	{
	/* Copy RINFO reason part only the first time
	* because we don't want to propagate the reason to
	* the subkeys. This assumes that we get the public
	* key first. */
	pk->flags.revoked = revoked;
	memcpy (&pk->revoked, &rinfo, sizeof (rinfo));
	if (rinfo.got_reason)
	{
	rinfo.got_reason = 0;
	rinfo.reason_code = 0;
	rinfo.reason_comment = NULL; /(owner is pk->revoked)/
	rinfo.reason_comment_len = 0;
	}
	}
	if (main_pk->has_expired)
	{
	pk->has_expired = main_pk->has_expired;
	if (!pk->expiredate \|\| pk->expiredate > main_pk->expiredate)
	pk->expiredate = main_pk->expiredate;
	}
	}
	}
	goto leave;
	}

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

	leave:
	xfree (rinfo.reason_comment);
	}



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

	if (r_flags)
	*r_flags = 0;


	/* The verify mode is used to change the behaviour so that we can
	* return an expired or revoked key for signature verification. */
	verify_mode = ((req_usage & PUBKEY_USAGE_VERIFY)
	&& (req_usage & (PUBKEY_USAGE_CERT\|PUBKEY_USAGE_SIG)));

	#define USAGE_MASK (PUBKEY_USAGE_SIG\|PUBKEY_USAGE_ENC\|PUBKEY_USAGE_CERT)
	req_usage &= USAGE_MASK;
	/* In allow ADSK mode make sure both encryption bits are set. */
	if (allow_adsk && (req_usage & PUBKEY_USAGE_XENC_MASK))
	req_usage \|= PUBKEY_USAGE_XENC_MASK;

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


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

	/* For an exact match mark the primary or subkey that matched the
	* low-level search criteria. Use this loop also to sort our keys
	* found using an ADSK fingerprint. */
	for (k = keyblock; k; k = k->next)
	{
	if ((k->flag & 1) && (k->pkt->pkttype == PKT_PUBLIC_KEY
	\|\| k->pkt->pkttype == PKT_PUBLIC_SUBKEY))
	{
	if (want_exact)
	{
	foundk = k;
	pk = k->pkt->pkt.public_key;
	pk->flags.exact = 1;
	diag_exactfound = 1;
	break;
	}
	else if (!allow_adsk && (k->pkt->pkt.public_key->pubkey_usage
	== PUBKEY_USAGE_RENC))
	{
	if (DBG_LOOKUP)
	log_debug ("finish_lookup: found via ADSK - not selected\n");
	if (r_flags)
	*r_flags \|= LOOKUP_NOT_SELECTED;
	return NULL; /* Not found. */
	}
	}
	}

	/* 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%s)\n",
	(ulong) keyid_from_pk (keyblock->pkt->pkt.public_key, NULL),
	foundk ? "one" : "all", req_usage, verify_mode? ",verify":"");
	if (diag_exactfound && DBG_LOOKUP)
	log_debug ("\texact search requested and found\n");

	if (!req_usage)
	{
	latest_key = foundk ? foundk : keyblock;
	if (DBG_LOOKUP)
	log_debug ("\tno usage requested - accepting key\n");
	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;
	int last_secret_key_avail = 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 \| PUBKEY_USAGE_RENC))
	& req_usage))
	{
	if (DBG_LOOKUP)
	log_debug ("\tusage does not match: want=%x have=%x\n",
	req_usage, pk->pubkey_usage);
	continue;
	}
	if (!verify_mode
	&& opt.flags.disable_pqc_encryption
	&& pk->pubkey_algo == PUBKEY_ALGO_KYBER)
	{
	if (DBG_LOOKUP)
	log_debug ("\tsubkey skipped due to option %s\n",
	"--disable-pqc-encryption");
	continue;
	}

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

	if (!verify_mode
	&& opt.flags.require_pqc_encryption
	&& (req_usage & PUBKEY_USAGE_XENC_MASK)
	&& pk->pubkey_algo != PUBKEY_ALGO_KYBER)
	{
	if (DBG_LOOKUP)
	log_debug ("\tsubkey is not quantum-resistant\n");
	continue;
	}


	if (!verify_mode && want_secret)
	{
	int secret_key_avail = agent_probe_secret_key (NULL, pk);

	if (!secret_key_avail)
	{
	if (DBG_LOOKUP)
	log_debug ("\tno secret key\n");
	continue;
	}

	if (secret_key_avail < last_secret_key_avail)
	{
	if (DBG_LOOKUP)
	log_debug ("\tskipping secret key with lower avail\n");
	continue;
	}

	if (secret_key_avail > last_secret_key_avail)
	{
	/* Use this key. */
	last_secret_key_avail = secret_key_avail;
	latest_date = 0;
	}
	}

	if (DBG_LOOKUP)
	log_debug ("\tsubkey might be fine%s\n",
	verify_mode? " for verification":"");
	/* 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 (!verify_mode && pk->flags.revoked)
	{
	if (DBG_LOOKUP)
	log_debug ("\tprimary key has been revoked\n");
	}
	else if (!verify_mode && pk->has_expired)
	{
	if (DBG_LOOKUP)
	log_debug ("\tprimary key has expired\n");
	}
	else if (!verify_mode
	&& opt.flags.require_pqc_encryption
	&& (req_usage & PUBKEY_USAGE_XENC_MASK)
	&& pk->pubkey_algo != PUBKEY_ALGO_KYBER)
	{
	if (DBG_LOOKUP)
	log_debug ("\tprimary key is not quantum-resistant\n");
	}
	else /* Okay. */
	{
	if (DBG_LOOKUP)
	log_debug ("\tprimary key may be used%s\n",
	verify_mode? " for verification":"");
	latest_key = keyblock;
	}
	}

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

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

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

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

	cache_put_keyblock (keyblock);

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


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

	if (!is_status_enabled ())
	return;

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

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



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

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

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

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

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

	if (want_secret)
	{
	rc = agent_probe_any_secret_key (ctrl, keyblock);
	if (gpg_err_code(rc) == GPG_ERR_NO_SECKEY)
	goto skip; /* No secret key available. */
	if (gpg_err_code (rc) == GPG_ERR_PUBKEY_ALGO)
	goto skip; /* Not implemented algo - skip. */
	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, ctx->allow_adsk,
	&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;
	}


	/* If a default key has been specified, return that key. If a card
	* based key is also available as indicated by FPR_CARD not being
	* NULL, return that key if suitable. */
	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;

	def_secret_key = parse_def_secret_key (ctrl);

	if (def_secret_key)
	add_to_strlist (&namelist, def_secret_key);
	else if (fpr_card)
	{
	err = get_pubkey_byfpr (ctrl, pk, NULL, fpr_card, fpr_len);
	if (gpg_err_code (err) == GPG_ERR_NO_PUBKEY)
	{
	if (opt.debug)
	log_debug ("using LDAP to find public key for current card\n");
	err = keyserver_import_fpr (ctrl, fpr_card, fpr_len,
	opt.keyserver,
	KEYSERVER_IMPORT_FLAG_LDAP);
	if (!err)
	err = get_pubkey_byfpr (ctrl, pk, NULL, fpr_card, fpr_len);
	else if (gpg_err_code (err) == GPG_ERR_NO_DATA
	\|\| gpg_err_code (err) == GPG_ERR_NO_KEYSERVER)
	{
	/* Dirmngr returns NO DATA is the selected keyserver
	* does not have the requested key. It returns NO
	* KEYSERVER if no LDAP keyservers are configured. */
	err = gpg_error (GPG_ERR_NO_PUBKEY);
	}
	}

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

	if (!fpr_card \|\| (def_secret_key && *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)
	goto leave;
	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);
	}

	leave:
	free_strlist (namelist);
	return err;
	}



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

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

	log_assert (mode != 2);

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

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

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

	return p;
	}


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


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


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

	if (r_nouid)
	*r_nouid = 0;

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

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

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


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


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

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

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

	return name;
	}

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


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

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

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

	xfree (akl);
	}

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


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

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

	return !any;
	}


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

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

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

	akl = xmalloc_clear (sizeof (*akl));

	if (ascii_strcasecmp (tok, "clear") == 0)
	{
	xfree (akl);
	free_akl (opt.auto_key_locate);
	opt.auto_key_locate = NULL;
	continue;
	}
	else if (ascii_strcasecmp (tok, "nodefault") == 0)
	akl->type = AKL_NODEFAULT;
	else if (ascii_strcasecmp (tok, "local") == 0)
	akl->type = AKL_LOCAL;
	else if (ascii_strcasecmp (tok, "ldap") == 0)
	akl->type = AKL_LDAP;
	else if (ascii_strcasecmp (tok, "keyserver") == 0)
	akl->type = AKL_KEYSERVER;
	else if (ascii_strcasecmp (tok, "cert") == 0)
	akl->type = AKL_CERT;
	else if (ascii_strcasecmp (tok, "pka") == 0)
	akl->type = AKL_PKA;
	else if (ascii_strcasecmp (tok, "dane") == 0)
	akl->type = AKL_DANE;
	else if (ascii_strcasecmp (tok, "wkd") == 0)
	akl->type = AKL_WKD;
	else if (ascii_strcasecmp (tok, "ntds") == 0)
	akl->type = AKL_NTDS;
	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 (ctrl_t ctrl, 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 (ctrl);
	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;
	}


	/* Return an error if KEYBLOCK has a primary or subkey with the given
	* fingerprint (FPR,FPRLEN). */
	gpg_error_t
	has_key_with_fingerprint (kbnode_t keyblock, const byte *fpr, size_t fprlen)
	{
	kbnode_t node;
	PKT_public_key *pk;
	byte pkfpr[MAX_FINGERPRINT_LEN];
	size_t pkfprlen;

	for (node = keyblock; node; node = node->next)
	{
	if (node->pkt->pkttype == PKT_PUBLIC_KEY
	\|\| node->pkt->pkttype == PKT_PUBLIC_SUBKEY
	\|\| node->pkt->pkttype == PKT_SECRET_KEY
	\|\| node->pkt->pkttype == PKT_SECRET_SUBKEY)
	{
	pk = node->pkt->pkt.public_key;
	fingerprint_from_pk (pk, pkfpr, &pkfprlen);
	if (pkfprlen == fprlen && !memcmp (pkfpr, fpr, fprlen))
	return gpg_error (GPG_ERR_DUP_KEY);
	}
	}
	return 0;
	}
	diff --git a/g10/import.c b/g10/import.c
	index 1ee818d61..effc38a93 100644
	--- a/g10/import.c
	+++ b/g10/import.c
	@@ -1,4869 +1,4876 @@
	/* import.c - import a key into our key storage.
	* Copyright (C) 1998-2007, 2010-2011 Free Software Foundation, Inc.
	* Copyright (C) 2014, 2016, 2017, 2019 Werner Koch
	*
	* This file is part of GnuPG.
	*
	* GnuPG is free software; you can redistribute it and/or modify
	* it under the terms of the GNU General Public License as published by
	* the Free Software Foundation; either version 3 of the License, or
	* (at your option) any later version.
	*
	* GnuPG is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with this program; if not, see <https://www.gnu.org/licenses/>.
	*/

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

	#include "gpg.h"
	#include "options.h"
	#include "packet.h"
	#include "../common/status.h"
	#include "keydb.h"
	#include "../common/util.h"
	#include "trustdb.h"
	#include "main.h"
	#include "../common/i18n.h"
	#include "../common/ttyio.h"
	#include "../common/recsel.h"
	#include "keyserver-internal.h"
	#include "call-agent.h"
	#include "../common/membuf.h"
	#include "../common/init.h"
	#include "../common/mbox-util.h"
	#include "key-check.h"
	#include "key-clean.h"


	struct import_stats_s
	{
	ulong count;
	ulong no_user_id;
	ulong imported;
	ulong n_uids;
	ulong n_sigs;
	ulong n_subk;
	ulong unchanged;
	ulong n_revoc;
	ulong secret_read;
	ulong secret_imported;
	ulong secret_dups;
	ulong skipped_new_keys;
	ulong not_imported;
	ulong n_sigs_cleaned;
	ulong n_uids_cleaned;
	ulong v3keys; /* Number of V3 keys seen. */
	};


	/* Node flag to indicate that a user ID or a subkey has a
	* valid self-signature. */
	#define NODE_GOOD_SELFSIG 1
	/* Node flag to indicate that a user ID or subkey has
	* an invalid self-signature. */
	#define NODE_BAD_SELFSIG 2
	/* Node flag to indicate that the node shall be deleted. */
	#define NODE_DELETION_MARK 4
	/* A node flag used to temporary mark a node. */
	#define NODE_FLAG_A 8
	/* A flag used by transfer_secret_keys. */
	#define NODE_TRANSFER_SECKEY 16


	/* An object and a global instance to store selectors created from
	* --import-filter keep-uid=EXPR.
	* --import-filter drop-sig=EXPR.
	*
	* FIXME: We should put this into the CTRL object but that requires a
	* lot more changes right now. For now we use save and restore
	* function to temporary change them.
	*/
	/* Definition of the import filters. */
	struct import_filter_s
	{
	recsel_expr_t keep_uid;
	recsel_expr_t drop_sig;
	};
	/* The current instance. */
	struct import_filter_s import_filter;


	static int import (ctrl_t ctrl,
	IOBUF inp, const char* fname, struct import_stats_s *stats,
	unsigned char *fpr, size_t fpr_len, unsigned int options,
	import_screener_t screener, void *screener_arg,
	int origin, const char *url);
	static int read_block (IOBUF a, unsigned int options,
	PACKET *pending_pkt, kbnode_t ret_root, int *r_v3keys);
	static void revocation_present (ctrl_t ctrl, kbnode_t keyblock);
	static gpg_error_t import_one (ctrl_t ctrl,
	kbnode_t keyblock,
	struct import_stats_s *stats,
	unsigned char *fpr, size_t fpr_len,
	unsigned int options, int from_sk, int silent,
	import_screener_t screener, void *screener_arg,
	int origin, const char url, int r_valid);
	static gpg_error_t import_matching_seckeys (
	ctrl_t ctrl, kbnode_t seckeys,
	const byte *mainfpr, size_t mainfprlen,
	struct import_stats_s *stats, int batch);
	static gpg_error_t import_secret_one (ctrl_t ctrl, kbnode_t keyblock,
	struct import_stats_s *stats, int batch,
	unsigned int options, int for_migration,
	import_screener_t screener, void *screener_arg,
	kbnode_t *r_secattic);
	static int import_revoke_cert (ctrl_t ctrl, kbnode_t node, unsigned int options,
	struct import_stats_s *stats);
	static int chk_self_sigs (ctrl_t ctrl, kbnode_t keyblock, u32 *keyid,
	int *non_self);
	static int delete_inv_parts (ctrl_t ctrl, kbnode_t keyblock,
	u32 *keyid, unsigned int options,
	kbnode_t *r_otherrevsigs);
	static int any_uid_left (kbnode_t keyblock);
	static void remove_all_non_self_sigs (kbnode_t keyblock, u32 keyid);
	static int merge_blocks (ctrl_t ctrl, unsigned int options,
	kbnode_t keyblock_orig,
	kbnode_t keyblock, u32 *keyid,
	u32 curtime, int origin, const char *url,
	int n_uids, int n_sigs, int *n_subk );
	static gpg_error_t append_new_uid (unsigned int options,
	kbnode_t keyblock, kbnode_t node,
	u32 curtime, int origin, const char *url,
	int *n_sigs);
	static int append_key (kbnode_t keyblock, kbnode_t node, int *n_sigs);
	static int merge_sigs (kbnode_t dst, kbnode_t src, int *n_sigs);
	static int merge_keysigs (kbnode_t dst, kbnode_t src, int *n_sigs);



	static void
	release_import_filter (import_filter_t filt)
	{
	recsel_release (filt->keep_uid);
	filt->keep_uid = NULL;
	recsel_release (filt->drop_sig);
	filt->drop_sig = NULL;
	}

	static void
	cleanup_import_globals (void)
	{
	release_import_filter (&import_filter);
	}


	int
	parse_import_options(char str,unsigned int options,int noisy)
	{
	struct parse_options import_opts[]=
	{
	{"import-local-sigs",IMPORT_LOCAL_SIGS,NULL,
	N_("import signatures that are marked as local-only")},

	{"repair-pks-subkey-bug",IMPORT_REPAIR_PKS_SUBKEY_BUG,NULL,
	N_("repair damage from the pks keyserver during import")},

	{"keep-ownertrust", IMPORT_KEEP_OWNERTTRUST, NULL,
	N_("do not clear the ownertrust values during import")},

	{"fast-import",IMPORT_FAST,NULL,
	N_("do not update the trustdb after import")},

	{"bulk-import",IMPORT_BULK, NULL,
	N_("enable bulk import mode")},

	{"import-show",IMPORT_SHOW,NULL,
	N_("show key during import")},

	{"show-only", (IMPORT_SHOW \| IMPORT_DRY_RUN), NULL,
	N_("show key but do not actually import") },

	{"merge-only",IMPORT_MERGE_ONLY,NULL,
	N_("only accept updates to existing keys")},

	{"import-clean",IMPORT_CLEAN,NULL,
	N_("remove unusable parts from key after import")},

	{"import-minimal",IMPORT_MINIMAL\|IMPORT_CLEAN,NULL,
	N_("remove as much as possible from key after import")},

	{"self-sigs-only", IMPORT_SELF_SIGS_ONLY, NULL,
	N_("ignore key-signatures which are not self-signatures")},

	{"import-export", IMPORT_EXPORT, NULL,
	N_("run import filters and export key immediately")},

	{"restore", IMPORT_RESTORE, NULL,
	N_("assume the GnuPG key backup format")},
	{"import-restore", IMPORT_RESTORE, NULL, NULL},

	{"repair-keys", IMPORT_REPAIR_KEYS, NULL,
	N_("repair keys on import")},

	/* New options. Right now, without description string. */
	{"ignore-attributes", IMPORT_IGNORE_ATTRIBUTES, NULL, NULL},

	{"only-pubkeys", IMPORT_ONLY_PUBKEYS, NULL,
	N_("do not import secret keys")},

	/* Hidden options which are enabled by default and are provided
	* in case of problems with the respective implementation. */
	{"collapse-uids", IMPORT_COLLAPSE_UIDS, NULL, NULL},
	{"collapse-subkeys", IMPORT_COLLAPSE_SUBKEYS, NULL, NULL},

	/* Aliases for backward compatibility */
	{"allow-local-sigs",IMPORT_LOCAL_SIGS,NULL,NULL},
	{"repair-hkp-subkey-bug",IMPORT_REPAIR_PKS_SUBKEY_BUG,NULL,NULL},
	/* dummy */
	{"import-unusable-sigs",0,NULL,NULL},
	{"import-clean-sigs",0,NULL,NULL},
	{"import-clean-uids",0,NULL,NULL},
	{"convert-sk-to-pk",0, NULL,NULL}, /* Not anymore needed due to
	the new design. */
	{NULL,0,NULL,NULL}
	};
	int rc;
	int saved_self_sigs_only, saved_import_clean;

	/* We need to set flags indicating whether the user has set certain
	* options or if they came from the default. */
	saved_self_sigs_only = (*options & IMPORT_SELF_SIGS_ONLY);
	saved_self_sigs_only &= ~IMPORT_SELF_SIGS_ONLY;
	saved_import_clean = (*options & IMPORT_CLEAN);
	saved_import_clean &= ~IMPORT_CLEAN;

	rc = parse_options (str, options, import_opts, noisy);

	if (rc && (*options & IMPORT_SELF_SIGS_ONLY))
	opt.flags.expl_import_self_sigs_only = 1;
	else
	*options \|= saved_self_sigs_only;

	if (rc && (*options & IMPORT_CLEAN))
	opt.flags.expl_import_clean = 1;
	else
	*options \|= saved_import_clean;


	if (rc && (*options & IMPORT_RESTORE))
	{
	/* Alter other options we want or don't want for restore. */
	*options \|= (IMPORT_LOCAL_SIGS \| IMPORT_KEEP_OWNERTTRUST);
	*options &= ~(IMPORT_MINIMAL \| IMPORT_CLEAN
	\| IMPORT_REPAIR_PKS_SUBKEY_BUG
	\| IMPORT_MERGE_ONLY);
	}
	return rc;
	}


	/* Parse and set an import filter from string. STRING has the format
	* "NAME=EXPR" with NAME being the name of the filter. Spaces before
	* and after NAME are not allowed. If this function is all called
	* several times all expressions for the same NAME are concatenated.
	* Supported filter names are:
	*
	* - keep-uid :: If the expression evaluates to true for a certain
	* user ID packet, that packet and all it dependencies
	* will be imported. The expression may use these
	* variables:
	*
	* - uid :: The entire user ID.
	* - mbox :: The mail box part of the user ID.
	* - primary :: Evaluate to true for the primary user ID.
	*/
	gpg_error_t
	parse_and_set_import_filter (const char *string)
	{
	gpg_error_t err;

	/* Auto register the cleanup function. */
	register_mem_cleanup_func (cleanup_import_globals);

	if (!strncmp (string, "keep-uid=", 9))
	err = recsel_parse_expr (&import_filter.keep_uid, string+9);
	else if (!strncmp (string, "drop-sig=", 9))
	err = recsel_parse_expr (&import_filter.drop_sig, string+9);
	else
	err = gpg_error (GPG_ERR_INV_NAME);

	return err;
	}


	/* Save the current import filters, return them, and clear the current
	* filters. Returns NULL on error and sets ERRNO. */
	import_filter_t
	save_and_clear_import_filter (void)
	{
	import_filter_t filt;

	filt = xtrycalloc (1, sizeof *filt);
	if (!filt)
	return NULL;
	*filt = import_filter;
	memset (&import_filter, 0, sizeof import_filter);

	return filt;
	}


	/* Release the current import filters and restore them from NEWFILT.
	* Ownership of NEWFILT is moved to this function. */
	void
	restore_import_filter (import_filter_t filt)
	{
	if (filt)
	{
	release_import_filter (&import_filter);
	import_filter = *filt;
	xfree (filt);
	}
	}


	import_stats_t
	import_new_stats_handle (void)
	{
	return xmalloc_clear ( sizeof (struct import_stats_s) );
	}


	void
	import_release_stats_handle (import_stats_t p)
	{
	xfree (p);
	}


	/* Read a key from a file. Only the first key in the file is
	* considered and stored at R_KEYBLOCK. FNAME is the name of the
	* file.
	*/
	gpg_error_t
	read_key_from_file_or_buffer (ctrl_t ctrl, const char *fname,
	const void *buffer, size_t buflen,
	kbnode_t *r_keyblock)
	{
	gpg_error_t err;
	iobuf_t inp;
	PACKET *pending_pkt = NULL;
	kbnode_t keyblock = NULL;
	u32 keyid[2];
	int v3keys; /* Dummy */
	int non_self; /* Dummy */

	(void)ctrl;

	*r_keyblock = NULL;

	log_assert (!!fname ^ !!buffer);

	if (fname)
	{
	inp = iobuf_open (fname);
	if (!inp)
	err = gpg_error_from_syserror ();
	else if (is_secured_file (iobuf_get_fd (inp)))
	{
	iobuf_close (inp);
	inp = NULL;
	err = gpg_error (GPG_ERR_EPERM);
	}
	else
	err = 0;
	if (err)
	{
	log_error (_("can't open '%s': %s\n"),
	iobuf_is_pipe_filename (fname)? "[stdin]": fname,
	gpg_strerror (err));
	if (gpg_err_code (err) == GPG_ERR_ENOENT)
	err = gpg_error (GPG_ERR_NO_PUBKEY);
	goto leave;
	}

	/* Push the armor filter. */
	{
	armor_filter_context_t *afx;
	afx = new_armor_context ();
	afx->only_keyblocks = 1;
	push_armor_filter (afx, inp);
	release_armor_context (afx);
	}

	}
	else /* Read from buffer (No armor expected). */
	{
	inp = iobuf_temp_with_content (buffer, buflen);
	}

	/* Read the first non-v3 keyblock. */
	while (!(err = read_block (inp, 0, &pending_pkt, &keyblock, &v3keys)))
	{
	if (keyblock->pkt->pkttype == PKT_PUBLIC_KEY)
	break;
	log_info (_("skipping block of type %d\n"), keyblock->pkt->pkttype);
	release_kbnode (keyblock);
	keyblock = NULL;
	}
	if (err)
	{
	if (gpg_err_code (err) != GPG_ERR_INV_KEYRING)
	log_error (_("error reading '%s': %s\n"),
	fname? (iobuf_is_pipe_filename (fname)? "[stdin]": fname)
	/* */ : "[buffer]",
	gpg_strerror (err));
	goto leave;
	}

	keyid_from_pk (keyblock->pkt->pkt.public_key, keyid);

	if (!find_next_kbnode (keyblock, PKT_USER_ID))
	{
	err = gpg_error (GPG_ERR_NO_USER_ID);
	goto leave;
	}

	/* We do the collapsing unconditionally although it is expected that
	* clean keys are provided here. */
	collapse_uids (&keyblock);
	collapse_subkeys (&keyblock);

	clear_kbnode_flags (keyblock);
	if (chk_self_sigs (ctrl, keyblock, keyid, &non_self))
	{
	err = gpg_error (GPG_ERR_INV_KEYRING);
	goto leave;
	}

	if (!delete_inv_parts (ctrl, keyblock, keyid, 0, NULL) )
	{
	err = gpg_error (GPG_ERR_NO_USER_ID);
	goto leave;
	}

	*r_keyblock = keyblock;
	keyblock = NULL;

	leave:
	if (inp)
	{
	iobuf_close (inp);
	/* Must invalidate that ugly cache to actually close the file. */
	if (fname)
	iobuf_ioctl (NULL, IOBUF_IOCTL_INVALIDATE_CACHE, 0, (char*)fname);
	}
	release_kbnode (keyblock);
	/* FIXME: Do we need to free PENDING_PKT ? */
	return err;
	}


	/* Import an already checked public key which was included in a
	* signature and the signature verified out using this key. */
	gpg_error_t
	import_included_key_block (ctrl_t ctrl, kbnode_t keyblock)
	{
	gpg_error_t err;
	struct import_stats_s *stats;
	import_filter_t save_filt;
	int save_armor = opt.armor;

	opt.armor = 0;
	stats = import_new_stats_handle ();
	save_filt = save_and_clear_import_filter ();
	if (!save_filt)
	{
	err = gpg_error_from_syserror ();
	goto leave;
	}

	/* FIXME: Should we introduce a dedicated KEYORG ? */
	err = import_one (ctrl, keyblock,
	stats, NULL, 0, 0, 0, 0,
	NULL, NULL, KEYORG_UNKNOWN, NULL, NULL);

	leave:
	restore_import_filter (save_filt);
	import_release_stats_handle (stats);
	opt.armor = save_armor;
	return err;
	}



	/*
	* Import the public keys from the given filename. Input may be armored.
	* This function rejects all keys which are not validly self signed on at
	* least one userid. Only user ids which are self signed will be imported.
	* Other signatures are not checked.
	*
	* Actually this function does a merge. It works like this:
	*
	* - get the keyblock
	* - check self-signatures and remove all userids and their signatures
	* without/invalid self-signatures.
	* - reject the keyblock, if we have no valid userid.
	* - See whether we have this key already in one of our pubrings.
	* If not, simply add it to the default keyring.
	* - Compare the key and the self-signatures of the new and the one in
	* our keyring. If they are different something weird is going on;
	* ask what to do.
	* - See whether we have only non-self-signature on one user id; if not
	* ask the user what to do.
	* - compare the signatures: If we already have this signature, check
	* that they compare okay; if not, issue a warning and ask the user.
	* (consider looking at the timestamp and use the newest?)
	* - Simply add the signature. Can't verify here because we may not have
	* the signature's public key yet; verification is done when putting it
	* into the trustdb, which is done automagically as soon as this pubkey
	* is used.
	* - Proceed with next signature.
	*
	* Key revocation certificates have special handling.
	*/
	static gpg_error_t
	import_keys_internal (ctrl_t ctrl, iobuf_t inp, char **fnames, int nnames,
	import_stats_t stats_handle,
	unsigned char *fpr, size_t fpr_len,
	unsigned int options,
	import_screener_t screener, void *screener_arg,
	int origin, const char *url)
	{
	int i;
	gpg_error_t err = 0;
	struct import_stats_s *stats = stats_handle;

	if (!stats)
	stats = import_new_stats_handle ();

	if (inp)
	{
	err = import (ctrl, inp, "[stream]", stats, fpr, fpr_len, options,
	screener, screener_arg, origin, url);
	}
	else
	{
	if (!fnames && !nnames)
	nnames = 1; /* Ohh what a ugly hack to jump into the loop */

	for (i=0; i < nnames; i++)
	{
	const char *fname = fnames? fnames[i] : NULL;
	IOBUF inp2 = iobuf_open(fname);

	if (!fname)
	fname = "[stdin]";
	if (inp2 && is_secured_file (iobuf_get_fd (inp2)))
	{
	iobuf_close (inp2);
	inp2 = NULL;
	gpg_err_set_errno (EPERM);
	}
	if (!inp2)
	log_error (_("can't open '%s': %s\n"), fname, strerror (errno));
	else
	{
	err = import (ctrl, inp2, fname, stats, fpr, fpr_len, options,
	screener, screener_arg, origin, url);
	iobuf_close (inp2);
	/* Must invalidate that ugly cache to actually close it. */
	iobuf_ioctl (NULL, IOBUF_IOCTL_INVALIDATE_CACHE, 0, (char*)fname);
	if (err)
	log_error ("import from '%s' failed: %s\n",
	fname, gpg_strerror (err) );
	}
	if (!fname)
	break;
	}
	}

	if (!stats_handle)
	{
	if ((options & (IMPORT_SHOW \| IMPORT_DRY_RUN))
	!= (IMPORT_SHOW \| IMPORT_DRY_RUN))
	import_print_stats (stats);
	import_release_stats_handle (stats);
	}

	/* If no fast import and the trustdb is dirty (i.e. we added a key
	or userID that had something other than a selfsig, a signature
	that was other than a selfsig, or any revocation), then
	update/check the trustdb if the user specified by setting
	interactive or by not setting no-auto-check-trustdb */

	if (!(options & IMPORT_FAST))
	check_or_update_trustdb (ctrl);

	return err;
	}


	void
	import_keys (ctrl_t ctrl, char **fnames, int nnames,
	import_stats_t stats_handle, unsigned int options,
	int origin, const char *url)
	{
	import_keys_internal (ctrl, NULL, fnames, nnames, stats_handle,
	NULL, NULL, options, NULL, NULL, origin, url);
	}


	gpg_error_t
	import_keys_es_stream (ctrl_t ctrl, estream_t fp,
	import_stats_t stats_handle,
	unsigned char *fpr, size_t fpr_len,
	unsigned int options,
	import_screener_t screener, void *screener_arg,
	int origin, const char *url)
	{
	gpg_error_t err;
	iobuf_t inp;

	inp = iobuf_esopen (fp, "rb", 1, 0);
	if (!inp)
	{
	err = gpg_error_from_syserror ();
	log_error ("iobuf_esopen failed: %s\n", gpg_strerror (err));
	return err;
	}

	err = import_keys_internal (ctrl, inp, NULL, 0, stats_handle,
	fpr, fpr_len, options,
	screener, screener_arg, origin, url);

	iobuf_close (inp);
	return err;
	}


	static int
	import (ctrl_t ctrl, IOBUF inp, const char* fname,struct import_stats_s *stats,
	unsigned char *fpr,size_t fpr_len, unsigned int options,
	import_screener_t screener, void *screener_arg,
	int origin, const char *url)
	{
	PACKET *pending_pkt = NULL;
	kbnode_t keyblock = NULL; /* Need to initialize because gcc can't
	grasp the return semantics of
	read_block. */
	kbnode_t secattic = NULL; /* Kludge for PGP desktop percularity */
	int rc = 0;
	int v3keys;

	getkey_disable_caches ();

	if (!opt.no_armor) /* Armored reading is not disabled. */
	{
	armor_filter_context_t *afx;

	afx = new_armor_context ();
	afx->only_keyblocks = 1;
	push_armor_filter (afx, inp);
	release_armor_context (afx);
	}

	while (!(rc = read_block (inp, options, &pending_pkt, &keyblock, &v3keys)))
	{
	stats->v3keys += v3keys;
	if (keyblock->pkt->pkttype == PKT_PUBLIC_KEY)
	{
	rc = import_one (ctrl, keyblock,
	stats, fpr, fpr_len, options, 0, 0,
	screener, screener_arg, origin, url, NULL);
	if (secattic)
	{
	byte tmpfpr[MAX_FINGERPRINT_LEN];
	size_t tmpfprlen;

	if (!rc && !(opt.dry_run \|\| (options & IMPORT_DRY_RUN)))
	{
	/* Kudge for PGP desktop - see below. */
	fingerprint_from_pk (keyblock->pkt->pkt.public_key,
	tmpfpr, &tmpfprlen);
	rc = import_matching_seckeys (ctrl, secattic,
	tmpfpr, tmpfprlen,
	stats, opt.batch);
	}
	release_kbnode (secattic);
	secattic = NULL;
	}
	}
	else if (keyblock->pkt->pkttype == PKT_SECRET_KEY)
	{
	release_kbnode (secattic);
	secattic = NULL;
	rc = import_secret_one (ctrl, keyblock, stats,
	opt.batch, options, 0,
	screener, screener_arg, &secattic);
	keyblock = NULL; /* Ownership was transferred. */
	if (secattic)
	{
	if (gpg_err_code (rc) == GPG_ERR_NO_PUBKEY)
	rc = 0; /* Try import after the next pubkey. */

	/* The attic is a workaround for the peculiar PGP
	* Desktop method of exporting a secret key: The
	* exported file is the concatenation of two armored
	* keyblocks; first the private one and then the public
	* one. The strange thing is that the secret one has no
	* binding signatures at all and thus we have not
	* imported it. The attic stores that secret keys and
	* we try to import it once after the very next public
	* keyblock. */
	}
	}
	else if (keyblock->pkt->pkttype == PKT_SIGNATURE
	&& IS_KEY_REV (keyblock->pkt->pkt.signature) )
	{
	release_kbnode (secattic);
	secattic = NULL;
	rc = import_revoke_cert (ctrl, keyblock, options, stats);
	}
	else
	{
	release_kbnode (secattic);
	secattic = NULL;
	log_info (_("skipping block of type %d\n"), keyblock->pkt->pkttype);
	}
	release_kbnode (keyblock);

	/* fixme: we should increment the not imported counter but
	this does only make sense if we keep on going despite of
	errors. For now we do this only if the imported key is too
	large. */
	if (gpg_err_code (rc) == GPG_ERR_TOO_LARGE
	&& gpg_err_source (rc) == GPG_ERR_SOURCE_KEYBOX)
	{
	stats->not_imported++;
	}
	else if (rc)
	break;

	if (!(++stats->count % 100) && !opt.quiet)
	log_info (_("%lu keys processed so far\n"), stats->count );

	if (origin == KEYORG_WKD && stats->count >= 5)
	{
	/* We limit the number of keys _received_ from the WKD to 5.
	* In fact there should be only one key but some sites want
	* to store a few expired keys there also. gpg's key
	* selection will later figure out which key to use. Note
	* that for WKD we always return the fingerprint of the
	* first imported key. */
	log_info ("import from WKD stopped after %d keys\n", 5);
	break;
	}
	}
	stats->v3keys += v3keys;
	if (rc == -1)
	rc = 0;
	else if (rc && gpg_err_code (rc) != GPG_ERR_INV_KEYRING)
	log_error (_("error reading '%s': %s\n"), fname, gpg_strerror (rc));

	release_kbnode (secattic);

	/* When read_block loop was stopped by error, we have PENDING_PKT left. */
	if (pending_pkt)
	{
	free_packet (pending_pkt, NULL);
	xfree (pending_pkt);
	}
	return rc;
	}


	/* Helper to migrate secring.gpg to GnuPG 2.1. */
	gpg_error_t
	import_old_secring (ctrl_t ctrl, const char *fname)
	{
	gpg_error_t err;
	iobuf_t inp;
	PACKET *pending_pkt = NULL;
	kbnode_t keyblock = NULL; /* Need to initialize because gcc can't
	grasp the return semantics of
	read_block. */
	struct import_stats_s *stats;
	int v3keys;

	inp = iobuf_open (fname);
	if (inp && is_secured_file (iobuf_get_fd (inp)))
	{
	iobuf_close (inp);
	inp = NULL;
	gpg_err_set_errno (EPERM);
	}
	if (!inp)
	{
	err = gpg_error_from_syserror ();
	log_error (_("can't open '%s': %s\n"), fname, gpg_strerror (err));
	return err;
	}

	getkey_disable_caches();
	stats = import_new_stats_handle ();
	while (!(err = read_block (inp, 0, &pending_pkt, &keyblock, &v3keys)))
	{
	if (keyblock->pkt->pkttype == PKT_SECRET_KEY)
	{
	err = import_secret_one (ctrl, keyblock, stats, 1, 0, 1,
	NULL, NULL, NULL);
	keyblock = NULL; /* Ownership was transferred. */
	}
	release_kbnode (keyblock);
	if (err)
	break;
	}
	import_release_stats_handle (stats);
	if (err == -1)
	err = 0;
	else if (err && gpg_err_code (err) != GPG_ERR_INV_KEYRING)
	log_error (_("error reading '%s': %s\n"), fname, gpg_strerror (err));
	else if (err)
	log_error ("import from '%s' failed: %s\n", fname, gpg_strerror (err));

	iobuf_close (inp);
	iobuf_ioctl (NULL, IOBUF_IOCTL_INVALIDATE_CACHE, 0, (char*)fname);

	return err;
	}


	void
	import_print_stats (import_stats_t stats)
	{
	if (!opt.quiet)
	{
	log_info(_("Total number processed: %lu\n"),
	stats->count + stats->v3keys);
	if (stats->v3keys)
	log_info(_(" skipped PGP-2 keys: %lu\n"), stats->v3keys);
	if (stats->skipped_new_keys )
	log_info(_(" skipped new keys: %lu\n"),
	stats->skipped_new_keys );
	if (stats->no_user_id )
	log_info(_(" w/o user IDs: %lu\n"), stats->no_user_id );
	if (stats->imported)
	{
	log_info(_(" imported: %lu"), stats->imported );
	log_printf ("\n");
	}
	if (stats->unchanged )
	log_info(_(" unchanged: %lu\n"), stats->unchanged );
	if (stats->n_uids )
	log_info(_(" new user IDs: %lu\n"), stats->n_uids );
	if (stats->n_subk )
	log_info(_(" new subkeys: %lu\n"), stats->n_subk );
	if (stats->n_sigs )
	log_info(_(" new signatures: %lu\n"), stats->n_sigs );
	if (stats->n_revoc )
	log_info(_(" new key revocations: %lu\n"), stats->n_revoc );
	if (stats->secret_read )
	log_info(_(" secret keys read: %lu\n"), stats->secret_read );
	if (stats->secret_imported )
	log_info(_(" secret keys imported: %lu\n"), stats->secret_imported );
	if (stats->secret_dups )
	log_info(_(" secret keys unchanged: %lu\n"), stats->secret_dups );
	if (stats->not_imported )
	log_info(_(" not imported: %lu\n"), stats->not_imported );
	if (stats->n_sigs_cleaned)
	log_info(_(" signatures cleaned: %lu\n"),stats->n_sigs_cleaned);
	if (stats->n_uids_cleaned)
	log_info(_(" user IDs cleaned: %lu\n"),stats->n_uids_cleaned);
	}

	if (is_status_enabled ())
	{
	char buf[15*20];

	snprintf (buf, sizeof buf,
	"%lu %lu %lu 0 %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu",
	stats->count + stats->v3keys,
	stats->no_user_id,
	stats->imported,
	stats->unchanged,
	stats->n_uids,
	stats->n_subk,
	stats->n_sigs,
	stats->n_revoc,
	stats->secret_read,
	stats->secret_imported,
	stats->secret_dups,
	stats->skipped_new_keys,
	stats->not_imported,
	stats->v3keys );
	write_status_text (STATUS_IMPORT_RES, buf);
	}
	}


	/* Return true if PKTTYPE is valid in a keyblock. */
	static int
	valid_keyblock_packet (int pkttype)
	{
	switch (pkttype)
	{
	case PKT_PUBLIC_KEY:
	case PKT_PUBLIC_SUBKEY:
	case PKT_SECRET_KEY:
	case PKT_SECRET_SUBKEY:
	case PKT_SIGNATURE:
	case PKT_USER_ID:
	case PKT_ATTRIBUTE:
	case PKT_RING_TRUST:
	return 1;
	default:
	return 0;
	}
	}


	/* Read the next keyblock from stream A. Meta data (ring trust
	* packets) are only considered if OPTIONS has the IMPORT_RESTORE flag
	* set. PENDING_PKT should be initialized to NULL and not changed by
	* the caller.
	*
	* Returns 0 for okay, -1 no more blocks, or any other errorcode. The
	* integer at R_V3KEY counts the number of unsupported v3 keyblocks.
	*/
	static int
	read_block( IOBUF a, unsigned int options,
	PACKET *pending_pkt, kbnode_t ret_root, int *r_v3keys)
	{
	int rc;
	struct parse_packet_ctx_s parsectx;
	PACKET *pkt;
	kbnode_t root = NULL;
	kbnode_t lastnode = NULL;
	int in_cert, in_v3key, skip_sigs;
	u32 keyid[2];
	int got_keyid = 0;
	unsigned int dropped_nonselfsigs = 0;

	*r_v3keys = 0;

	if (*pending_pkt)
	{
	root = lastnode = new_kbnode( *pending_pkt );
	*pending_pkt = NULL;
	log_assert (root->pkt->pkttype == PKT_PUBLIC_KEY
	\|\| root->pkt->pkttype == PKT_SECRET_KEY);
	in_cert = 1;
	keyid_from_pk (root->pkt->pkt.public_key, keyid);
	got_keyid = 1;
	}
	else
	in_cert = 0;

	pkt = xmalloc (sizeof *pkt);
	init_packet (pkt);
	init_parse_packet (&parsectx, a);
	if (!(options & IMPORT_RESTORE))
	parsectx.skip_meta = 1;
	in_v3key = 0;
	skip_sigs = 0;
	while ((rc=parse_packet (&parsectx, pkt)) != -1)
	{
	if (rc && (gpg_err_code (rc) == GPG_ERR_LEGACY_KEY
	&& (pkt->pkttype == PKT_PUBLIC_KEY
	\|\| pkt->pkttype == PKT_SECRET_KEY)))
	{
	in_v3key = 1;
	++*r_v3keys;
	free_packet (pkt, &parsectx);
	init_packet (pkt);
	continue;
	}
	else if (rc ) /* (ignore errors) */
	{
	skip_sigs = 0;
	if (gpg_err_code (rc) == GPG_ERR_UNKNOWN_PACKET)
	; /* Do not show a diagnostic. */
	else if (gpg_err_code (rc) == GPG_ERR_INV_PACKET
	&& (pkt->pkttype == PKT_USER_ID
	\|\| pkt->pkttype == PKT_ATTRIBUTE))
	{
	/* This indicates a too large user id or attribute
	* packet. We skip this packet and all following
	* signatures. Sure, this won't allow to repair a
	* garbled keyring in case one of the signatures belong
	* to another user id. However, this better mitigates
	* DoS using inserted user ids. */
	skip_sigs = 1;
	}
	else if (gpg_err_code (rc) == GPG_ERR_INV_PACKET
	&& (pkt->pkttype == PKT_OLD_COMMENT
	\|\| pkt->pkttype == PKT_COMMENT))
	; /* Ignore too large comment packets. */
	else
	{
	log_error("read_block: read error: %s\n", gpg_strerror (rc) );
	rc = GPG_ERR_INV_KEYRING;
	goto ready;
	}
	free_packet (pkt, &parsectx);
	init_packet(pkt);
	continue;
	}
	else if ((opt.import_options & IMPORT_IGNORE_ATTRIBUTES)
	&& (pkt->pkttype == PKT_USER_ID \|\| pkt->pkttype == PKT_ATTRIBUTE)
	&& pkt->pkt.user_id->attrib_data)
	{
	skip_sigs = 1;
	free_packet (pkt, &parsectx);
	init_packet (pkt);
	continue;
	}

	if (skip_sigs)
	{
	if (pkt->pkttype == PKT_SIGNATURE)
	{
	free_packet (pkt, &parsectx);
	init_packet (pkt);
	continue;
	}
	skip_sigs = 0;
	}

	if (in_v3key && !(pkt->pkttype == PKT_PUBLIC_KEY
	\|\| pkt->pkttype == PKT_SECRET_KEY))
	{
	free_packet (pkt, &parsectx);
	init_packet(pkt);
	continue;
	}
	in_v3key = 0;

	if (!root && pkt->pkttype == PKT_SIGNATURE
	&& IS_KEY_REV (pkt->pkt.signature) )
	{
	/* This is a revocation certificate which is handled in a
	* special way. */
	root = new_kbnode( pkt );
	pkt = NULL;
	goto ready;
	}

	/* Make a linked list of all packets. */
	switch (pkt->pkttype)
	{
	case PKT_COMPRESSED:
	if (!(opt.compat_flags & COMPAT_COMPR_KEYS))
	{
	rc = GPG_ERR_UNEXPECTED_PACKET;
	goto ready;
	}
	else if (check_compress_algo (pkt->pkt.compressed->algorithm))
	{
	rc = GPG_ERR_COMPR_ALGO;
	goto ready;
	}
	else
	{
	compress_filter_context_t cfx = xmalloc_clear( sizeof cfx );
	pkt->pkt.compressed->buf = NULL;
	if (push_compress_filter2 (a, cfx,
	pkt->pkt.compressed->algorithm, 1))
	xfree (cfx); /* e.g. in case of compression_algo NONE. */
	}
	free_packet (pkt, &parsectx);
	init_packet(pkt);
	break;

	case PKT_RING_TRUST:
	/* Skip those packets unless we are in restore mode. */
	if ((opt.import_options & IMPORT_RESTORE))
	goto x_default;
	free_packet (pkt, &parsectx);
	init_packet(pkt);
	break;

	case PKT_SIGNATURE:
	if (!in_cert)
	goto x_default;
	if (!(options & IMPORT_SELF_SIGS_ONLY))
	goto x_default;
	log_assert (got_keyid);
	if (pkt->pkt.signature->keyid[0] == keyid[0]
	&& pkt->pkt.signature->keyid[1] == keyid[1])
	{ /* This is likely a self-signature. We import this one.
	* Eventually we should use the ISSUER_FPR to compare
	* self-signatures, but that will work only for v5 keys
	* which are currently not even deployed.
	* Note that we do not do any crypto verify here because
	* that would defeat this very mitigation of DoS by
	* importing a key with a huge amount of faked
	* key-signatures. A verification will be done later in
	* the processing anyway. Here we want a cheap an early
	* way to drop non-self-signatures. */
	goto x_default;
	}
	/* Skip this signature. */
	dropped_nonselfsigs++;
	free_packet (pkt, &parsectx);
	init_packet(pkt);
	break;

	case PKT_PUBLIC_KEY:
	case PKT_SECRET_KEY:
	if (!got_keyid)
	{
	keyid_from_pk (pkt->pkt.public_key, keyid);
	got_keyid = 1;
	}
	if (in_cert) /* Store this packet. */
	{
	*pending_pkt = pkt;
	pkt = NULL;
	goto ready;
	}
	in_cert = 1;
	goto x_default;

	default:
	x_default:
	if (in_cert && valid_keyblock_packet (pkt->pkttype))
	{
	if (!root )
	root = lastnode = new_kbnode (pkt);
	else
	{
	lastnode->next = new_kbnode (pkt);
	lastnode = lastnode->next;
	}
	pkt = xmalloc (sizeof *pkt);
	}
	else
	free_packet (pkt, &parsectx);
	init_packet(pkt);
	break;
	}
	}

	ready:
	if (rc == -1 && root )
	rc = 0;

	if (rc )
	release_kbnode( root );
	else
	*ret_root = root;
	free_packet (pkt, &parsectx);
	deinit_parse_packet (&parsectx);
	xfree( pkt );
	if (!rc && dropped_nonselfsigs && opt.verbose)
	log_info ("key %s: number of dropped non-self-signatures: %u\n",
	keystr (keyid), dropped_nonselfsigs);

	return rc;
	}


	/* Walk through the subkeys on a pk to find if we have the PKS
	disease: multiple subkeys with their binding sigs stripped, and the
	sig for the first subkey placed after the last subkey. That is,
	instead of "pk uid sig sub1 bind1 sub2 bind2 sub3 bind3" we have
	"pk uid sig sub1 sub2 sub3 bind1". We can't do anything about sub2
	and sub3, as they are already lost, but we can try and rescue sub1
	by reordering the keyblock so that it reads "pk uid sig sub1 bind1
	sub2 sub3". Returns TRUE if the keyblock was modified. */
	static int
	fix_pks_corruption (ctrl_t ctrl, kbnode_t keyblock)
	{
	int changed = 0;
	int keycount = 0;
	kbnode_t node;
	kbnode_t last = NULL;
	kbnode_t sknode=NULL;

	/* First determine if we have the problem at all. Look for 2 or
	more subkeys in a row, followed by a single binding sig. */
	for (node=keyblock; node; last=node, node=node->next)
	{
	if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
	{
	keycount++;
	if(!sknode)
	sknode=node;
	}
	else if (node->pkt->pkttype == PKT_SIGNATURE
	&& IS_SUBKEY_SIG (node->pkt->pkt.signature)
	&& keycount >= 2
	&& !node->next)
	{
	/* We might have the problem, as this key has two subkeys in
	a row without any intervening packets. */

	/* Sanity check */
	if (!last)
	break;

	/* Temporarily attach node to sknode. */
	node->next = sknode->next;
	sknode->next = node;
	last->next = NULL;

	/* Note we aren't checking whether this binding sig is a
	selfsig. This is not necessary here as the subkey and
	binding sig will be rejected later if that is the
	case. */
	if (check_key_signature (ctrl, keyblock,node,NULL))
	{
	/* Not a match, so undo the changes. */
	sknode->next = node->next;
	last->next = node;
	node->next = NULL;
	break;
	}
	else
	{
	/* Mark it good so we don't need to check it again */
	sknode->flag \|= NODE_GOOD_SELFSIG;
	changed = 1;
	break;
	}
	}
	else
	keycount = 0;
	}

	return changed;
	}


	/* Versions of GnuPG before 1.4.11 and 2.0.16 allowed to import bogus
	direct key signatures. A side effect of this was that a later
	import of the same good direct key signatures was not possible
	because the cmp_signature check in merge_blocks considered them
	equal. Although direct key signatures are now checked during
	import, there might still be bogus signatures sitting in a keyring.
	We need to detect and delete them before doing a merge. This
	function returns the number of removed sigs. */
	static int
	fix_bad_direct_key_sigs (ctrl_t ctrl, kbnode_t keyblock, u32 *keyid)
	{
	gpg_error_t err;
	kbnode_t node;
	int count = 0;

	for (node = keyblock->next; node; node=node->next)
	{
	if (node->pkt->pkttype == PKT_USER_ID)
	break;
	if (node->pkt->pkttype == PKT_SIGNATURE
	&& IS_KEY_SIG (node->pkt->pkt.signature))
	{
	err = check_key_signature (ctrl, keyblock, node, NULL);
	if (err && gpg_err_code (err) != GPG_ERR_PUBKEY_ALGO )
	{
	/* If we don't know the error, we can't decide; this is
	not a problem because cmp_signature can't compare the
	signature either. */
	log_info ("key %s: invalid direct key signature removed\n",
	keystr (keyid));
	delete_kbnode (node);
	count++;
	}
	}
	}

	return count;
	}


	static void
	print_import_ok (PKT_public_key *pk, unsigned int reason)
	{
	byte array[MAX_FINGERPRINT_LEN], *s;
	char buf[MAX_FINGERPRINT_LEN2+30], p;
	size_t i, n;

	snprintf (buf, sizeof buf, "%u ", reason);
	p = buf + strlen (buf);

	fingerprint_from_pk (pk, array, &n);
	s = array;
	for (i=0; i < n ; i++, s++, p += 2)
	sprintf (p, "%02X", *s);

	write_status_text (STATUS_IMPORT_OK, buf);
	}


	static void
	print_import_check (PKT_public_key * pk, PKT_user_id * id)
	{
	byte hexfpr[2*MAX_FINGERPRINT_LEN+1];
	u32 keyid[2];

	keyid_from_pk (pk, keyid);
	hexfingerprint (pk, hexfpr, sizeof hexfpr);
	write_status_printf (STATUS_IMPORT_CHECK, "%08X%08X %s %s",
	keyid[0], keyid[1], hexfpr, id->name);

	}


	static void
	check_prefs_warning(PKT_public_key *pk)
	{
	log_info(_("WARNING: key %s contains preferences for unavailable\n"
	"algorithms on these user IDs:\n"), keystr_from_pk(pk));
	}


	static void
	check_prefs (ctrl_t ctrl, kbnode_t keyblock)
	{
	kbnode_t node;
	PKT_public_key *pk;
	int problem=0;

	merge_keys_and_selfsig (ctrl, keyblock);
	pk=keyblock->pkt->pkt.public_key;

	for(node=keyblock;node;node=node->next)
	{
	if(node->pkt->pkttype==PKT_USER_ID
	&& node->pkt->pkt.user_id->created
	&& node->pkt->pkt.user_id->prefs)
	{
	PKT_user_id *uid = node->pkt->pkt.user_id;
	prefitem_t *prefs = uid->prefs;
	char *user = utf8_to_native(uid->name,strlen(uid->name),0);

	for(;prefs->type;prefs++)
	{
	char num[10]; /* prefs->value is a byte, so we're over
	safe here */

	sprintf(num,"%u",prefs->value);

	if(prefs->type==PREFTYPE_SYM)
	{
	if (openpgp_cipher_test_algo (prefs->value))
	{
	const char *algo =
	(openpgp_cipher_test_algo (prefs->value)
	? num
	: openpgp_cipher_algo_name (prefs->value));
	if(!problem)
	check_prefs_warning(pk);
	log_info(_(" \"%s\": preference for cipher"
	" algorithm %s\n"), user, algo);
	problem=1;
	}
	}
	else if(prefs->type==PREFTYPE_AEAD)
	{
	if (openpgp_aead_test_algo (prefs->value))
	{
	/* FIXME: The test below is wrong. We should
	* check if ...algo_name yields a "?" and
	* only in that case use NUM. */
	const char *algo =
	(openpgp_aead_test_algo (prefs->value)
	? num
	: openpgp_aead_algo_name (prefs->value));
	if(!problem)
	check_prefs_warning(pk);
	log_info(_(" \"%s\": preference for AEAD"
	" algorithm %s\n"), user, algo);
	problem=1;
	}
	}
	else if(prefs->type==PREFTYPE_HASH)
	{
	if(openpgp_md_test_algo(prefs->value))
	{
	const char *algo =
	(gcry_md_test_algo (prefs->value)
	? num
	: gcry_md_algo_name (prefs->value));
	if(!problem)
	check_prefs_warning(pk);
	log_info(_(" \"%s\": preference for digest"
	" algorithm %s\n"), user, algo);
	problem=1;
	}
	}
	else if(prefs->type==PREFTYPE_ZIP)
	{
	if(check_compress_algo (prefs->value))
	{
	const char *algo=compress_algo_to_string(prefs->value);
	if(!problem)
	check_prefs_warning(pk);
	log_info(_(" \"%s\": preference for compression"
	" algorithm %s\n"),user,algo?algo:num);
	problem=1;
	}
	}
	}

	xfree(user);
	}
	}

	if(problem)
	{
	log_info(_("it is strongly suggested that you update"
	" your preferences and\n"));
	log_info(_("re-distribute this key to avoid potential algorithm"
	" mismatch problems\n"));

	if(!opt.batch)
	{
	strlist_t sl = NULL;
	strlist_t locusr = NULL;
	size_t fprlen=0;
	byte fpr[MAX_FINGERPRINT_LEN], *p;
	char username[(MAX_FINGERPRINT_LEN*2)+1];
	unsigned int i;

	p = fingerprint_from_pk (pk,fpr,&fprlen);
	for(i=0;i<fprlen;i++,p++)
	sprintf(username+2i,"%02X",p);
	add_to_strlist(&locusr,username);

	append_to_strlist(&sl,"updpref");
	append_to_strlist(&sl,"save");

	keyedit_menu (ctrl, username, locusr, sl, 1, 1 );
	free_strlist(sl);
	free_strlist(locusr);
	}
	else if(!opt.quiet)
	log_info(_("you can update your preferences with:"
	" gpg --edit-key %s updpref save\n"),keystr_from_pk(pk));
	}
	}


	/* Helper for apply_*_filter in import.c and export.c and also used by
	* keylist.c. */
	const char *
	impex_filter_getval (void cookie, const char propname)
	{
	/* FIXME: Malloc our static buffers and access them via PARM. */
	struct impex_filter_parm_s *parm = cookie;
	ctrl_t ctrl = parm->ctrl;
	kbnode_t node = parm->node;
	static char numbuf[20];
	const char *result;
	const char *s;
	enum { scpNone = 0, scpPub, scpSub, scpUid, scpSig} scope = 0;

	log_assert (ctrl && ctrl->magic == SERVER_CONTROL_MAGIC);

	/* We allow a prefix delimited by a slash to limit the scope of the
	* keyword. Note that "pub" also includes "sec" and "sub" includes
	* "ssb". */
	if (DBG_RECSEL) /* Printing the packet type is useful. */
	log_debug ("%s: pkttype=%s\n", __func__, pkttype_str (node->pkt->pkttype));
	if ((s=strchr (propname, '/')) && s != propname)
	{
	size_t n = s - propname;
	if (!strncmp (propname, "pub", n))
	scope = scpPub;
	else if (!strncmp (propname, "sub", n))
	scope = scpSub;
	else if (!strncmp (propname, "uid", n))
	scope = scpUid;
	else if (!strncmp (propname, "sig", n))
	scope = scpSig;

	propname = s + 1;
	}

	if ((node->pkt->pkttype == PKT_USER_ID
	\|\| node->pkt->pkttype == PKT_ATTRIBUTE)
	&& (!scope \|\| scope == scpUid))
	{
	PKT_user_id *uid = node->pkt->pkt.user_id;

	if (!strcmp (propname, "uid"))
	result = uid->name;
	else if (!strcmp (propname, "mbox"))
	{
	if (!uid->mbox)
	{
	uid->mbox = mailbox_from_userid (uid->name, 0);
	}
	result = uid->mbox;
	}
	else if (!strcmp (propname, "primary"))
	{
	result = uid->flags.primary? "1":"0";
	}
	else if (!strcmp (propname, "expired"))
	{
	result = uid->flags.expired? "1":"0";
	}
	else if (!strcmp (propname, "revoked"))
	{
	result = uid->flags.revoked? "1":"0";
	}
	else
	result = NULL;
	}
	else if (node->pkt->pkttype == PKT_SIGNATURE
	&& (!scope \|\| scope == scpSig))
	{
	PKT_signature *sig = node->pkt->pkt.signature;

	if (!strcmp (propname, "sig_created"))
	{
	snprintf (numbuf, sizeof numbuf, "%lu", (ulong)sig->timestamp);
	result = numbuf;
	}
	else if (!strcmp (propname, "sig_created_d"))
	{
	result = dateonlystr_from_sig (sig);
	}
	else if (!strcmp (propname, "sig_expires"))
	{
	snprintf (numbuf, sizeof numbuf, "%lu", (ulong)sig->expiredate);
	result = numbuf;
	}
	else if (!strcmp (propname, "sig_expires_d"))
	{
	static char exdatestr[MK_DATESTR_SIZE];

	if (sig->expiredate)
	result = mk_datestr (exdatestr, sizeof exdatestr, sig->expiredate);
	else
	result = "";
	}
	else if (!strcmp (propname, "sig_algo"))
	{
	snprintf (numbuf, sizeof numbuf, "%d", sig->pubkey_algo);
	result = numbuf;
	}
	else if (!strcmp (propname, "sig_digest_algo"))
	{
	snprintf (numbuf, sizeof numbuf, "%d", sig->digest_algo);
	result = numbuf;
	}
	else if (!strcmp (propname, "expired"))
	{
	result = sig->flags.expired? "1":"0";
	}
	else
	result = NULL;
	}
	else if (((node->pkt->pkttype == PKT_PUBLIC_KEY
	\|\| node->pkt->pkttype == PKT_SECRET_KEY)
	&& (!scope \|\| scope == scpPub))
	\|\| ((node->pkt->pkttype == PKT_PUBLIC_SUBKEY
	\|\| node->pkt->pkttype == PKT_SECRET_SUBKEY)
	&& (!scope \|\| scope == scpSub)))
	{
	PKT_public_key *pk = node->pkt->pkt.public_key;

	if (!strcmp (propname, "secret"))
	{
	result = (node->pkt->pkttype == PKT_SECRET_KEY
	\|\| node->pkt->pkttype == PKT_SECRET_SUBKEY)? "1":"0";
	}
	else if (!strcmp (propname, "key_algo"))
	{
	snprintf (numbuf, sizeof numbuf, "%d", pk->pubkey_algo);
	result = numbuf;
	}
	else if (!strcmp (propname, "key_size"))
	{
	snprintf (numbuf, sizeof numbuf, "%u", nbits_from_pk (pk));
	result = numbuf;
	}
	else if (!strcmp (propname, "algostr"))
	{
	pubkey_string (pk, parm->hexfpr, sizeof parm->hexfpr);
	result = parm->hexfpr;
	}
	else if (!strcmp (propname, "key_created"))
	{
	snprintf (numbuf, sizeof numbuf, "%lu", (ulong)pk->timestamp);
	result = numbuf;
	}
	else if (!strcmp (propname, "key_created_d"))
	{
	result = dateonlystr_from_pk (pk);
	}
	else if (!strcmp (propname, "key_expires"))
	{
	snprintf (numbuf, sizeof numbuf, "%lu", (ulong)pk->expiredate);
	result = numbuf;
	}
	else if (!strcmp (propname, "key_expires_d"))
	{
	static char exdatestr[MK_DATESTR_SIZE];

	if (pk->expiredate)
	result = mk_datestr (exdatestr, sizeof exdatestr, pk->expiredate);
	else
	result = "";
	}
	else if (!strcmp (propname, "expired"))
	{
	result = pk->has_expired? "1":"0";
	}
	else if (!strcmp (propname, "revoked"))
	{
	result = pk->flags.revoked? "1":"0";
	}
	else if (!strcmp (propname, "disabled"))
	{
	result = pk_is_disabled (pk)? "1":"0";
	}
	else if (!strcmp (propname, "usage"))
	{
	snprintf (numbuf, sizeof numbuf, "%s%s%s%s%s",
	(pk->pubkey_usage & PUBKEY_USAGE_ENC)?"e":"",
	(pk->pubkey_usage & PUBKEY_USAGE_SIG)?"s":"",
	(pk->pubkey_usage & PUBKEY_USAGE_CERT)?"c":"",
	(pk->pubkey_usage & PUBKEY_USAGE_AUTH)?"a":"",
	(pk->pubkey_usage & PUBKEY_USAGE_UNKNOWN)?"?":"");
	result = numbuf;
	}
	else if (!strcmp (propname, "fpr"))
	{
	hexfingerprint (pk, parm->hexfpr, sizeof parm->hexfpr);
	result = parm->hexfpr;
	}
	else if (!strcmp (propname, "origin"))
	{
	result = key_origin_string (pk->keyorg);
	}
	else if (!strcmp (propname, "lastupd"))
	{
	snprintf (numbuf, sizeof numbuf, "%lu", (ulong)pk->keyupdate);
	result = numbuf;
	}
	else if (!strcmp (propname, "url"))
	{
	if (pk->updateurl && *pk->updateurl)
	{
	/* Fixme: This might get truncated. */
	mem2str (parm->hexfpr, pk->updateurl, sizeof parm->hexfpr);
	result = parm->hexfpr;
	}
	else
	result = "";
	}
	else
	result = NULL;
	}
	else
	result = NULL;

	return result;
	}


	/*
	* Apply the keep-uid filter to the keyblock. The deleted nodes are
	* marked and thus the caller should call commit_kbnode afterwards.
	* KEYBLOCK must not have any blocks marked as deleted.
	*/
	static void
	apply_keep_uid_filter (ctrl_t ctrl, kbnode_t keyblock, recsel_expr_t selector)
	{
	kbnode_t node;
	struct impex_filter_parm_s parm;

	parm.ctrl = ctrl;

	for (node = keyblock->next; node; node = node->next )
	{
	if (node->pkt->pkttype == PKT_USER_ID)
	{
	parm.node = node;
	if (!recsel_select (selector, impex_filter_getval, &parm))
	{

	/* log_debug ("keep-uid: deleting '%s'\n", */
	/* node->pkt->pkt.user_id->name); */
	/* The UID packet and all following packets up to the
	* next UID or a subkey. */
	delete_kbnode (node);
	for (; node->next
	&& node->next->pkt->pkttype != PKT_USER_ID
	&& node->next->pkt->pkttype != PKT_PUBLIC_SUBKEY
	&& node->next->pkt->pkttype != PKT_SECRET_SUBKEY ;
	node = node->next)
	delete_kbnode (node->next);
	}
	/* else */
	/* log_debug ("keep-uid: keeping '%s'\n", */
	/* node->pkt->pkt.user_id->name); */
	}
	}
	}


	/*
	* Apply the drop-sig filter to the keyblock. The deleted nodes are
	* marked and thus the caller should call commit_kbnode afterwards.
	* KEYBLOCK must not have any blocks marked as deleted.
	*/
	static void
	apply_drop_sig_filter (ctrl_t ctrl, kbnode_t keyblock, recsel_expr_t selector)
	{
	kbnode_t node;
	int active = 0;
	u32 main_keyid[2];
	PKT_signature *sig;
	struct impex_filter_parm_s parm;

	parm.ctrl = ctrl;

	keyid_from_pk (keyblock->pkt->pkt.public_key, main_keyid);

	/* Loop over all signatures for user id and attribute packets which
	* are not self signatures. */
	for (node = keyblock->next; node; node = node->next )
	{
	if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY
	\|\| node->pkt->pkttype == PKT_SECRET_SUBKEY)
	break; /* ready. */
	if (node->pkt->pkttype == PKT_USER_ID
	\|\| node->pkt->pkttype == PKT_ATTRIBUTE)
	active = 1;
	if (!active)
	continue;
	if (node->pkt->pkttype != PKT_SIGNATURE)
	continue;

	sig = node->pkt->pkt.signature;
	if (main_keyid[0] == sig->keyid[0] \|\| main_keyid[1] == sig->keyid[1])
	continue; /* Skip self-signatures. */

	if (IS_UID_SIG(sig) \|\| IS_UID_REV(sig))
	{
	parm.node = node;
	if (recsel_select (selector, impex_filter_getval, &parm))
	delete_kbnode (node);
	}
	}
	}


	/* Insert a key origin into a public key packet. */
	static gpg_error_t
	insert_key_origin_pk (PKT_public_key *pk, u32 curtime,
	int origin, const char *url)
	{
	if (origin == KEYORG_WKD \|\| origin == KEYORG_DANE)
	{
	/* For WKD and DANE we insert origin information also for the
	* key but we don't record the URL because we have have no use
	* for that: An update using a keyserver has higher precedence
	* and will thus update this origin info. For refresh using WKD
	* or DANE we need to go via the User ID anyway. Recall that we
	* are only inserting a new key. */
	pk->keyorg = origin;
	pk->keyupdate = curtime;
	}
	else if (origin == KEYORG_KS && url)
	{
	/* If the key was retrieved from a keyserver using a fingerprint
	* request we add the meta information. Note that the use of a
	* fingerprint needs to be enforced by the caller of the import
	* function. This is commonly triggered by verifying a modern
	* signature which has an Issuer Fingerprint signature
	* subpacket. */
	pk->keyorg = origin;
	pk->keyupdate = curtime;
	xfree (pk->updateurl);
	pk->updateurl = xtrystrdup (url);
	if (!pk->updateurl)
	return gpg_error_from_syserror ();
	}
	else if (origin == KEYORG_FILE)
	{
	pk->keyorg = origin;
	pk->keyupdate = curtime;
	}
	else if (origin == KEYORG_URL)
	{
	pk->keyorg = origin;
	pk->keyupdate = curtime;
	if (url)
	{
	xfree (pk->updateurl);
	pk->updateurl = xtrystrdup (url);
	if (!pk->updateurl)
	return gpg_error_from_syserror ();
	}
	}

	return 0;
	}


	/* Insert a key origin into a user id packet. */
	static gpg_error_t
	insert_key_origin_uid (PKT_user_id *uid, u32 curtime,
	int origin, const char *url)

	{
	if (origin == KEYORG_WKD \|\| origin == KEYORG_DANE)
	{
	/* We insert origin information on a UID only when we received
	* them via the Web Key Directory or a DANE record. The key we
	* receive here from the WKD has been filtered to contain only
	* the user ID as looked up in the WKD. For a DANE origin
	* this should also be the case. Thus we will see here only one
	* user id. */
	uid->keyorg = origin;
	uid->keyupdate = curtime;
	if (url)
	{
	xfree (uid->updateurl);
	uid->updateurl = xtrystrdup (url);
	if (!uid->updateurl)
	return gpg_error_from_syserror ();
	}
	}
	else if (origin == KEYORG_KS && url)
	{
	/* If the key was retrieved from a keyserver using a fingerprint
	* request we mark that also in the user ID. However we do not
	* store the keyserver URL in the UID. A later update (merge)
	* from a more trusted source will replace this info. */
	uid->keyorg = origin;
	uid->keyupdate = curtime;
	}
	else if (origin == KEYORG_FILE)
	{
	uid->keyorg = origin;
	uid->keyupdate = curtime;
	}
	else if (origin == KEYORG_URL)
	{
	uid->keyorg = origin;
	uid->keyupdate = curtime;
	}

	return 0;
	}


	/* Apply meta data to KEYBLOCK. This sets the origin of the key to
	* ORIGIN and the updateurl to URL. Note that this function is only
	* used for a new key, that is not when we are merging keys. */
	static gpg_error_t
	insert_key_origin (kbnode_t keyblock, int origin, const char *url)
	{
	gpg_error_t err;
	kbnode_t node;
	u32 curtime = make_timestamp ();

	for (node = keyblock; node; node = node->next)
	{
	if (is_deleted_kbnode (node))
	;
	else if (node->pkt->pkttype == PKT_PUBLIC_KEY)
	{
	err = insert_key_origin_pk (node->pkt->pkt.public_key, curtime,
	origin, url);
	if (err)
	return err;
	}
	else if (node->pkt->pkttype == PKT_USER_ID)
	{
	err = insert_key_origin_uid (node->pkt->pkt.user_id, curtime,
	origin, url);
	if (err)
	return err;
	}
	}

	return 0;
	}


	/* Update meta data on KEYBLOCK. This updates the key origin on the
	* public key according to ORIGIN and URL. The UIDs are already
	* updated when this function is called. */
	static gpg_error_t
	update_key_origin (kbnode_t keyblock, u32 curtime, int origin, const char *url)
	{
	PKT_public_key *pk;

	log_assert (keyblock->pkt->pkttype == PKT_PUBLIC_KEY);
	pk = keyblock->pkt->pkt.public_key;

	if (pk->keyupdate > curtime)
	; /* Don't do it for a time warp. */
	else if (origin == KEYORG_WKD \|\| origin == KEYORG_DANE)
	{
	/* We only update the origin info if they either have never been
	* set or are the origin was the same as the new one. If this
	* is WKD we also update the UID to show from which user id this
	* was updated. */
	if (!pk->keyorg \|\| pk->keyorg == KEYORG_WKD \|\| pk->keyorg == KEYORG_DANE)
	{
	pk->keyorg = origin;
	pk->keyupdate = curtime;
	xfree (pk->updateurl);
	pk->updateurl = NULL;
	if (origin == KEYORG_WKD && url)
	{
	pk->updateurl = xtrystrdup (url);
	if (!pk->updateurl)
	return gpg_error_from_syserror ();
	}
	}
	}
	else if (origin == KEYORG_KS)
	{
	/* All updates from a keyserver are considered to have the
	* freshed key. Thus we always set the new key origin. */
	pk->keyorg = origin;
	pk->keyupdate = curtime;
	xfree (pk->updateurl);
	pk->updateurl = NULL;
	if (url)
	{
	pk->updateurl = xtrystrdup (url);
	if (!pk->updateurl)
	return gpg_error_from_syserror ();
	}
	}
	else if (origin == KEYORG_FILE)
	{
	/* Updates from a file are considered to be fresh. */
	pk->keyorg = origin;
	pk->keyupdate = curtime;
	xfree (pk->updateurl);
	pk->updateurl = NULL;
	}
	else if (origin == KEYORG_URL)
	{
	/* Updates from a URL are considered to be fresh. */
	pk->keyorg = origin;
	pk->keyupdate = curtime;
	xfree (pk->updateurl);
	pk->updateurl = NULL;
	if (url)
	{
	pk->updateurl = xtrystrdup (url);
	if (!pk->updateurl)
	return gpg_error_from_syserror ();
	}
	}

	return 0;
	}


	/*
	* Try to import one keyblock. Return an error only in serious cases,
	* but never for an invalid keyblock. It uses log_error to increase
	* the internal errorcount, so that invalid input can be detected by
	* programs which called gpg. If SILENT is no messages are printed -
	* even most error messages are suppressed. ORIGIN is the origin of
	* the key (0 for unknown) and URL the corresponding URL. FROM_SK
	* indicates that the key has been made from a secret key. If R_SAVED
	* is not NULL a boolean will be stored indicating whether the
	* keyblock has valid parts. Unless OTHERREVSIGS is NULL it is
	* updated with encountered new revocation signatures.
	*/
	static gpg_error_t
	import_one_real (ctrl_t ctrl,
	kbnode_t keyblock, struct import_stats_s *stats,
	unsigned char *fpr, size_t fpr_len, unsigned int options,
	int from_sk, int silent,
	import_screener_t screener, void *screener_arg,
	int origin, const char url, int r_valid,
	kbnode_t *otherrevsigs)
	{
	gpg_error_t err = 0;
	PKT_public_key *pk;
	kbnode_t node, uidnode;
	kbnode_t keyblock_orig = NULL;
	byte fpr2[MAX_FINGERPRINT_LEN];
	size_t fpr2len;
	u32 keyid[2];
	int new_key = 0;
	int mod_key = 0;
	int same_key = 0;
	int non_self_or_utk = 0;
	char pkstrbuf[PUBKEY_STRING_SIZE];
	int merge_keys_done = 0;
	int any_filter = 0;
	KEYDB_HANDLE hd = NULL;

	if (r_valid)
	*r_valid = 0;

	/* If show-only is active we don't won't any extra output. */
	if ((options & (IMPORT_SHOW \| IMPORT_DRY_RUN)))
	silent = 1;

	/* Get the key and print some info about it. */
	node = find_kbnode( keyblock, PKT_PUBLIC_KEY );
	if (!node )
	BUG();

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

	fingerprint_from_pk (pk, fpr2, &fpr2len);
	if (MAX_FINGERPRINT_LEN > fpr2len)
	memset (fpr2+fpr2len, 0, MAX_FINGERPRINT_LEN - fpr2len);
	keyid_from_pk( pk, keyid );
	uidnode = find_next_kbnode( keyblock, PKT_USER_ID );

	if (opt.verbose && !opt.interactive && !silent && !from_sk)
	{
	/* Note that we do not print this info in FROM_SK mode
	* because import_secret_one already printed that. */
	log_info ("pub %s/%s %s ",
	pubkey_string (pk, pkstrbuf, sizeof pkstrbuf),
	keystr_from_pk(pk), datestr_from_pk(pk) );
	if (uidnode)
	print_utf8_buffer (log_get_stream (),
	uidnode->pkt->pkt.user_id->name,
	uidnode->pkt->pkt.user_id->len );
	log_printf ("\n");
	}


	if (!uidnode)
	{
	if (!silent)
	log_error( _("key %s: no user ID\n"), keystr_from_pk(pk));
	return 0;
	}

	if (screener && screener (keyblock, screener_arg))
	{
	log_error (_("key %s: %s\n"), keystr_from_pk (pk),
	_("rejected by import screener"));
	return 0;
	}

	if (opt.interactive && !silent)
	{
	if (is_status_enabled())
	print_import_check (pk, uidnode->pkt->pkt.user_id);
	merge_keys_and_selfsig (ctrl, keyblock);
	tty_printf ("\n");
	show_basic_key_info (ctrl, keyblock, from_sk);
	tty_printf ("\n");
	if (!cpr_get_answer_is_yes ("import.okay",
	"Do you want to import this key? (y/N) "))
	return 0;
	}

	/* Remove all non-self-sigs if requested. Note that this is a NOP if
	* that option has been globally set but we may also be called
	* latter with the already parsed keyblock and a locally changed
	* option. This is why we need to remove them here as well. */
	if ((options & IMPORT_SELF_SIGS_ONLY))
	remove_all_non_self_sigs (&keyblock, keyid);

	/* Remove or collapse the user ids. */
	if ((options & IMPORT_COLLAPSE_UIDS))
	collapse_uids (&keyblock);

	if ((options & IMPORT_COLLAPSE_SUBKEYS))
	collapse_subkeys (&keyblock);

	/* Clean the key that we're about to import, to cut down on things
	that we have to clean later. This has no practical impact on the
	end result, but does result in less logging which might confuse
	the user. */
	if ((options & IMPORT_CLEAN))
	{
	merge_keys_and_selfsig (ctrl, keyblock);
	clean_all_uids (ctrl, keyblock,
	opt.verbose,
	(options&IMPORT_MINIMAL)? EXPORT_MINIMAL : 0,
	NULL, NULL);
	clean_all_subkeys (ctrl, keyblock, opt.verbose, KEY_CLEAN_NONE,
	NULL, NULL);
	}

	clear_kbnode_flags( keyblock );

	if ((options&IMPORT_REPAIR_PKS_SUBKEY_BUG)
	&& fix_pks_corruption (ctrl, keyblock)
	&& opt.verbose)
	log_info (_("key %s: PKS subkey corruption repaired\n"),
	keystr_from_pk(pk));

	if ((options & IMPORT_REPAIR_KEYS))
	key_check_all_keysigs (ctrl, 1, keyblock, 0, 0);

	if (chk_self_sigs (ctrl, keyblock, keyid, &non_self_or_utk))
	return 0; /* Invalid keyblock - error already printed. */

	/* If the imported key is marked as ultimately trusted key (using
	* --trusted-key), we set the flag so that we can later set the
	* revalidation mark. */
	if (!non_self_or_utk)
	{
	/* Make sure the trustdb is initialized so that the UTK list is
	* available. */
	init_trustdb (ctrl, 1);
	if (tdb_keyid_is_utk (keyid))
	non_self_or_utk = 2;
	}

	/* If we allow such a thing, mark unsigned uids as valid */
	if (opt.allow_non_selfsigned_uid)
	{
	for (node=keyblock; node; node = node->next )
	if (node->pkt->pkttype == PKT_USER_ID
	&& !(node->flag & NODE_GOOD_SELFSIG)
	&& !(node->flag & NODE_BAD_SELFSIG) )
	{
	char *user=utf8_to_native(node->pkt->pkt.user_id->name,
	node->pkt->pkt.user_id->len,0);
	/* Fake a good signature status for the user id. */
	node->flag \|= NODE_GOOD_SELFSIG;
	log_info( _("key %s: accepted non self-signed user ID \"%s\"\n"),
	keystr_from_pk(pk),user);
	xfree(user);
	}
	}

	/* Delete invalid parts and bail out if there are no user ids left. */
	if (!delete_inv_parts (ctrl, keyblock, keyid, options, otherrevsigs))
	{
	if (!silent)
	{
	log_error ( _("key %s: no valid user IDs\n"), keystr_from_pk(pk));
	if (!opt.quiet)
	log_info(_("this may be caused by a missing self-signature\n"));
	}
	stats->no_user_id++;
	return 0;
	}

	/* Get rid of deleted nodes. */
	commit_kbnode (&keyblock);

	/* Apply import filter. */
	if (import_filter.keep_uid)
	{
	apply_keep_uid_filter (ctrl, keyblock, import_filter.keep_uid);
	commit_kbnode (&keyblock);
	any_filter = 1;
	}
	if (import_filter.drop_sig)
	{
	apply_drop_sig_filter (ctrl, keyblock, import_filter.drop_sig);
	commit_kbnode (&keyblock);
	any_filter = 1;
	}

	/* If we ran any filter we need to check that at least one user id
	* is left in the keyring. Note that we do not use log_error in
	* this case. */
	if (any_filter && !any_uid_left (keyblock))
	{
	if (!opt.quiet )
	log_info ( _("key %s: no valid user IDs\n"), keystr_from_pk (pk));
	stats->no_user_id++;
	return 0;
	}

	/* The keyblock is valid and ready for real import. */
	if (r_valid)
	*r_valid = 1;

	/* Show the key in the form it is merged or inserted. We skip this
	* if "import-export" is also active without --armor or the output
	* file has explicily been given. */
	if ((options & IMPORT_SHOW)
	&& !((options & IMPORT_EXPORT) && !opt.armor && !opt.outfile))
	{
	merge_keys_and_selfsig (ctrl, keyblock);
	merge_keys_done = 1;
	/* Note that we do not want to show the validity because the key
	* has not yet imported. */
	err = list_keyblock_direct (ctrl, keyblock, from_sk, 0,
	opt.fingerprint \|\| opt.with_fingerprint, 1);
	es_fflush (es_stdout);
	no_usable_encr_subkeys_warning (keyblock);
	if (err)
	goto leave;
	}

	/* Write the keyblock to the output and do not actually import. */
	if ((options & IMPORT_EXPORT))
	{
	if (!merge_keys_done)
	{
	merge_keys_and_selfsig (ctrl, keyblock);
	merge_keys_done = 1;
	}
	err = write_keyblock_to_output (keyblock, opt.armor, opt.export_options);
	goto leave;
	}

	if (opt.dry_run \|\| (options & IMPORT_DRY_RUN))
	goto leave;

	/* Do we have this key already in one of our pubrings ? */
	err = get_keyblock_byfpr_fast (ctrl, &keyblock_orig, &hd,
	1 /primary only /,
	fpr2, fpr2len, 1/locked/);
	if ((err
	&& gpg_err_code (err) != GPG_ERR_NO_PUBKEY
	&& gpg_err_code (err) != GPG_ERR_UNUSABLE_PUBKEY)
	\|\| !hd)
	{
	/* The !hd above is to catch a misbehaving function which
	* returns NO_PUBKEY for failing to allocate a handle. */
	if (!silent)
	log_error (_("key %s: public key not found: %s\n"),
	keystr(keyid), gpg_strerror (err));
	}
	else if (err && ((opt.import_options\|options)&IMPORT_MERGE_ONLY) )
	{
	if (opt.verbose && !silent )
	log_info( _("key %s: new key - skipped\n"), keystr(keyid));
	err = 0;
	stats->skipped_new_keys++;
	}
	else if (err) /* Insert this key. */
	{
	/* Note: ERR can only be NO_PUBKEY or UNUSABLE_PUBKEY. */
	int n_sigs_cleaned, n_uids_cleaned;

	err = keydb_locate_writable (hd);
	if (err)
	{
	log_error (_("no writable keyring found: %s\n"), gpg_strerror (err));
	err = gpg_error (GPG_ERR_GENERAL);
	goto leave;
	}
	if (opt.verbose > 1 )
	log_info (_("writing to '%s'\n"), keydb_get_resource_name (hd) );

	if ((options & IMPORT_CLEAN))
	{
	merge_keys_and_selfsig (ctrl, keyblock);
	clean_all_uids (ctrl, keyblock, opt.verbose,
	(options&IMPORT_MINIMAL)? EXPORT_MINIMAL : 0,
	&n_uids_cleaned,&n_sigs_cleaned);
	clean_all_subkeys (ctrl, keyblock, opt.verbose, KEY_CLEAN_NONE,
	NULL, NULL);
	}

	/* Unless we are in restore mode apply meta data to the
	* keyblock. Note that this will never change the first packet
	* and thus the address of KEYBLOCK won't change. */
	if ( !(options & IMPORT_RESTORE) )
	{
	err = insert_key_origin (keyblock, origin, url);
	if (err)
	{
	log_error ("insert_key_origin failed: %s\n", gpg_strerror (err));
	err = gpg_error (GPG_ERR_GENERAL);
	goto leave;
	}
	}

	- err = keydb_insert_keyblock (hd, keyblock );
	+ err = keydb_insert_keyblock (hd, keyblock);
	if (err)
	log_error (_("error writing keyring '%s': %s\n"),
	keydb_get_resource_name (hd), gpg_strerror (err));
	else if (!(opt.import_options & IMPORT_KEEP_OWNERTTRUST))
	{
	/* This should not be possible since we delete the
	ownertrust when a key is deleted, but it can happen if
	the keyring and trustdb are out of sync. It can also
	be made to happen with the trusted-key command and by
	importing and locally exported key. */

	clear_ownertrusts (ctrl, pk);
	if (non_self_or_utk)
	revalidation_mark (ctrl);
	}

	/* Release the handle and thus unlock the keyring asap. */
	keydb_release (hd);
	hd = NULL;

	/* We are ready. */
	if (!err && !opt.quiet && !silent)
	{
	char *p = get_user_id_byfpr_native (ctrl, fpr2, fpr2len);
	log_info (_("key %s: public key \"%s\" imported\n"),
	keystr(keyid), p);
	xfree(p);
	}
	if (!err && is_status_enabled())
	{
	char *us = get_long_user_id_string (ctrl, keyid);
	write_status_text( STATUS_IMPORTED, us );
	xfree(us);
	print_import_ok (pk, 1);
	}
	if (!err)
	{
	stats->imported++;
	new_key = 1;
	}
	}
	else /* Key already exists - merge. */
	{
	int n_uids, n_sigs, n_subk, n_sigs_cleaned, n_uids_cleaned;
	u32 curtime = make_timestamp ();

	/* Compare the original against the new key; just to be sure nothing
	* weird is going on */
	if (cmp_public_keys (keyblock_orig->pkt->pkt.public_key, pk))
	{
	if (!silent)
	log_error( _("key %s: doesn't match our copy\n"),keystr(keyid));
	goto leave;
	}

	/* Make sure the original direct key sigs are all sane. */
	n_sigs_cleaned = fix_bad_direct_key_sigs (ctrl, keyblock_orig, keyid);
	if (n_sigs_cleaned)
	commit_kbnode (&keyblock_orig);

	/* Try to merge KEYBLOCK into KEYBLOCK_ORIG. */
	clear_kbnode_flags( keyblock_orig );
	clear_kbnode_flags( keyblock );
	n_uids = n_sigs = n_subk = n_uids_cleaned = 0;
	err = merge_blocks (ctrl, options, keyblock_orig, keyblock, keyid,
	curtime, origin, url,
	&n_uids, &n_sigs, &n_subk );
	if (err)
	goto leave;

	/* Clean the final keyblock again if requested. we can't do
	* this if only self-signatures are imported; see bug #4628. */
	if ((options & IMPORT_CLEAN)
	&& !(options & IMPORT_SELF_SIGS_ONLY))
	{
	merge_keys_and_selfsig (ctrl, keyblock_orig);
	clean_all_uids (ctrl, keyblock_orig, opt.verbose,
	(options&IMPORT_MINIMAL)? EXPORT_MINIMAL : 0,
	&n_uids_cleaned,&n_sigs_cleaned);
	clean_all_subkeys (ctrl, keyblock_orig, opt.verbose, KEY_CLEAN_NONE,
	NULL, NULL);
	}

	if (n_uids \|\| n_sigs \|\| n_subk \|\| n_sigs_cleaned \|\| n_uids_cleaned)
	{
	/* Unless we are in restore mode apply meta data to the
	* keyblock. Note that this will never change the first packet
	* and thus the address of KEYBLOCK won't change. */
	if ( !(options & IMPORT_RESTORE) )
	{
	err = update_key_origin (keyblock_orig, curtime, origin, url);
	if (err)
	{
	log_error ("update_key_origin failed: %s\n",
	gpg_strerror (err));
	goto leave;
	}
	}

	mod_key = 1;
	/* KEYBLOCK_ORIG has been updated; write */
	err = keydb_update_keyblock (ctrl, hd, keyblock_orig);
	if (err)
	log_error (_("error writing keyring '%s': %s\n"),
	keydb_get_resource_name (hd), gpg_strerror (err));
	else if (non_self_or_utk)
	revalidation_mark (ctrl);

	/* Release the handle and thus unlock the keyring asap. */
	keydb_release (hd);
	hd = NULL;

	/* We are ready. Print and update stats if we got no error.
	* An error here comes from writing the keyblock and thus
	* very likely means that no update happened. */
	if (!err && !opt.quiet && !silent)
	{
	char *p = get_user_id_byfpr_native (ctrl, fpr2, fpr2len);
	if (n_uids == 1 )
	log_info( _("key %s: \"%s\" 1 new user ID\n"),
	keystr(keyid),p);
	else if (n_uids )
	log_info( _("key %s: \"%s\" %d new user IDs\n"),
	keystr(keyid),p,n_uids);
	if (n_sigs == 1 )
	log_info( _("key %s: \"%s\" 1 new signature\n"),
	keystr(keyid), p);
	else if (n_sigs )
	log_info( _("key %s: \"%s\" %d new signatures\n"),
	keystr(keyid), p, n_sigs );
	if (n_subk == 1 )
	log_info( _("key %s: \"%s\" 1 new subkey\n"),
	keystr(keyid), p);
	else if (n_subk )
	log_info( _("key %s: \"%s\" %d new subkeys\n"),
	keystr(keyid), p, n_subk );
	if (n_sigs_cleaned==1)
	log_info(_("key %s: \"%s\" %d signature cleaned\n"),
	keystr(keyid),p,n_sigs_cleaned);
	else if (n_sigs_cleaned)
	log_info(_("key %s: \"%s\" %d signatures cleaned\n"),
	keystr(keyid),p,n_sigs_cleaned);
	if (n_uids_cleaned==1)
	log_info(_("key %s: \"%s\" %d user ID cleaned\n"),
	keystr(keyid),p,n_uids_cleaned);
	else if (n_uids_cleaned)
	log_info(_("key %s: \"%s\" %d user IDs cleaned\n"),
	keystr(keyid),p,n_uids_cleaned);
	xfree(p);
	}

	if (!err)
	{
	stats->n_uids +=n_uids;
	stats->n_sigs +=n_sigs;
	stats->n_subk +=n_subk;
	stats->n_sigs_cleaned +=n_sigs_cleaned;
	stats->n_uids_cleaned +=n_uids_cleaned;

	if (is_status_enabled () && !silent)
	print_import_ok (pk, ((n_uids?2:0)\|(n_sigs?4:0)\|(n_subk?8:0)));
	}
	}
	else
	{
	/* Release the handle and thus unlock the keyring asap. */
	keydb_release (hd);
	hd = NULL;

	/* FIXME: We do not track the time we last checked a key for
	* updates. To do this we would need to rewrite even the
	* keys which have no changes. Adding this would be useful
	* for the automatic update of expired keys via the WKD in
	* case the WKD still carries the expired key. See
	* get_best_pubkey_byname. */
	same_key = 1;
	if (is_status_enabled ())
	print_import_ok (pk, 0);

	if (!opt.quiet && !silent)
	{
	char *p = get_user_id_byfpr_native (ctrl, fpr2, fpr2len);
	log_info( _("key %s: \"%s\" not changed\n"),keystr(keyid),p);
	xfree(p);
	}

	stats->unchanged++;
	}
	}

	leave:
	keydb_release (hd);
	if (mod_key \|\| new_key \|\| same_key)
	{
	/* A little explanation for this: we fill in the fingerprint
	when importing keys as it can be useful to know the
	fingerprint in certain keyserver-related cases (a keyserver
	asked for a particular name, but the key doesn't have that
	name). However, in cases where we're importing more than
	one key at a time, we cannot know which key to fingerprint.
	In these cases, rather than guessing, we do not
	fingerprinting at all, and we must hope the user ID on the
	keys are useful. Note that we need to do this for new
	keys, merged keys and even for unchanged keys. This is
	required because for example the --auto-key-locate feature
	may import an already imported key and needs to know the
	fingerprint of the key in all cases. */
	if (fpr)
	{
	/* Note that we need to compare against 0 here because
	COUNT gets only incremented after returning from this
	function. */
	if (!stats->count)
	{
	xfree (*fpr);
	*fpr = fingerprint_from_pk (pk, NULL, fpr_len);
	}
	else if (origin != KEYORG_WKD)
	{
	xfree (*fpr);
	*fpr = NULL;
	}
	}
	}

	/* Now that the key is definitely incorporated into the keydb, we
	need to check if a designated revocation is present or if the
	prefs are not rational so we can warn the user. */

	if (mod_key)
	{
	revocation_present (ctrl, keyblock_orig);
	if (!from_sk && have_secret_key_with_kid (ctrl, keyid))
	check_prefs (ctrl, keyblock_orig);
	}
	else if (new_key)
	{
	revocation_present (ctrl, keyblock);
	if (!from_sk && have_secret_key_with_kid (ctrl, keyid))
	check_prefs (ctrl, keyblock);
	}

	release_kbnode( keyblock_orig );

	return err;
	}


	/* Wrapper around import_one_real to retry the import in some cases. */
	static gpg_error_t
	import_one (ctrl_t ctrl,
	kbnode_t keyblock, struct import_stats_s *stats,
	unsigned char *fpr, size_t fpr_len, unsigned int options,
	int from_sk, int silent,
	import_screener_t screener, void *screener_arg,
	int origin, const char url, int r_valid)
	{
	gpg_error_t err;
	kbnode_t otherrevsigs = NULL;
	kbnode_t node;

	err = import_one_real (ctrl, keyblock, stats, fpr, fpr_len, options,
	from_sk, silent, screener, screener_arg,
	origin, url, r_valid, &otherrevsigs);
	if (gpg_err_code (err) == GPG_ERR_TOO_LARGE
	&& gpg_err_source (err) == GPG_ERR_SOURCE_KEYBOX
	&& ((options & (IMPORT_SELF_SIGS_ONLY \| IMPORT_CLEAN))
	!= (IMPORT_SELF_SIGS_ONLY \| IMPORT_CLEAN)))
	{
	/* We hit the maximum image length. Ask the wrapper to do
	* everything again but this time with some extra options. */
	u32 keyid[2];

	keyid_from_pk (keyblock->pkt->pkt.public_key, keyid);
	log_info ("key %s: keyblock too large, retrying with self-sigs-only\n",
	keystr (keyid));
	options \|= IMPORT_SELF_SIGS_ONLY \| IMPORT_CLEAN;
	err = import_one_real (ctrl, keyblock, stats, fpr, fpr_len, options,
	from_sk, silent, screener, screener_arg,
	origin, url, r_valid, &otherrevsigs);
	}

	/* Finally try to import other revocation certificates. For example
	* those of a former key appended to the current key. */
	if (!err)
	{
	for (node = otherrevsigs; node; node = node->next)
	import_revoke_cert (ctrl, node, options, stats);
	}
	release_kbnode (otherrevsigs);
	return err;
	}


	/* Transfer all the secret keys in SEC_KEYBLOCK to the gpg-agent. The
	* function prints diagnostics and returns an error code. If BATCH is
	* true the secret keys are stored by gpg-agent in the transfer format
	* (i.e. no re-protection and aksing for passphrases). If ONLY_MARKED
	* is set, only those nodes with flag NODE_TRANSFER_SECKEY are
	* processed. */
	gpg_error_t
	transfer_secret_keys (ctrl_t ctrl, struct import_stats_s *stats,
	kbnode_t sec_keyblock, int batch, int force,
	int only_marked)
	{
	gpg_error_t err = 0;
	void *kek = NULL;
	size_t keklen;
	kbnode_t ctx = NULL;
	kbnode_t node;
	PKT_public_key main_pk, pk;
	struct seckey_info *ski;
	int nskey;
	membuf_t mbuf;
	int i, j;
	void format_args[2PUBKEY_MAX_NSKEY];
	gcry_sexp_t skey, prot, tmpsexp;
	gcry_sexp_t curve = NULL;
	unsigned char *transferkey = NULL;
	size_t transferkeylen;
	gcry_cipher_hd_t cipherhd = NULL;
	unsigned char *wrappedkey = NULL;
	size_t wrappedkeylen;
	char *cache_nonce = NULL;
	int stub_key_skipped = 0;

	/* Get the current KEK. */
	err = agent_keywrap_key (ctrl, 0, &kek, &keklen);
	if (err)
	{
	log_error ("error getting the KEK: %s\n", gpg_strerror (err));
	goto leave;
	}

	/* Prepare a cipher context. */
	err = gcry_cipher_open (&cipherhd, GCRY_CIPHER_AES128,
	GCRY_CIPHER_MODE_AESWRAP, 0);
	if (!err)
	err = gcry_cipher_setkey (cipherhd, kek, keklen);
	if (err)
	goto leave;
	xfree (kek);
	kek = NULL;

	/* Note: We need to use walk_kbnode so that we skip nodes which are
	* marked as deleted. */
	main_pk = NULL;
	while ((node = walk_kbnode (sec_keyblock, &ctx, 0)))
	{
	if (node->pkt->pkttype != PKT_SECRET_KEY
	&& node->pkt->pkttype != PKT_SECRET_SUBKEY)
	continue;
	if (only_marked && !(node->flag & NODE_TRANSFER_SECKEY))
	continue;
	pk = node->pkt->pkt.public_key;
	if (!main_pk)
	main_pk = pk;

	/* Make sure the keyids are available. */
	keyid_from_pk (pk, NULL);
	if (node->pkt->pkttype == PKT_SECRET_KEY)
	{
	pk->main_keyid[0] = pk->keyid[0];
	pk->main_keyid[1] = pk->keyid[1];
	}
	else
	{
	pk->main_keyid[0] = main_pk->keyid[0];
	pk->main_keyid[1] = main_pk->keyid[1];
	}


	ski = pk->seckey_info;
	if (!ski)
	BUG ();

	if (stats)
	{
	stats->count++;
	stats->secret_read++;
	}

	/* We ignore stub keys. The way we handle them in other parts
	of the code is by asking the agent whether any secret key is
	available for a given keyblock and then concluding that we
	have a secret key; all secret (sub)keys of the keyblock the
	agent does not know of are then stub keys. This works also
	for card stub keys. The learn command or the card-status
	command may be used to check with the agent whether a card
	has been inserted and a stub key is in turn generated by the
	agent. */
	if (ski->s2k.mode == 1001 \|\| ski->s2k.mode == 1002)
	{
	stub_key_skipped = 1;
	continue;
	}

	/* Convert our internal secret key object into an S-expression. */
	nskey = pubkey_get_nskey (pk->pubkey_algo);
	if (!nskey \|\| nskey > PUBKEY_MAX_NSKEY)
	{
	err = gpg_error (GPG_ERR_BAD_SECKEY);
	log_error ("internal error: %s\n", gpg_strerror (err));
	goto leave;
	}

	init_membuf (&mbuf, 50);
	put_membuf_str (&mbuf, "(skey");
	if (pk->pubkey_algo == PUBKEY_ALGO_ECDSA
	\|\| pk->pubkey_algo == PUBKEY_ALGO_EDDSA
	\|\| pk->pubkey_algo == PUBKEY_ALGO_ECDH)
	{
	/* The ECC case. */
	char *curvestr = openpgp_oid_to_str (pk->pkey[0]);
	if (!curvestr)
	err = gpg_error_from_syserror ();
	else
	{
	const char *curvename = openpgp_oid_to_curve (curvestr, 1);
	gcry_sexp_release (curve);
	err = gcry_sexp_build (&curve, NULL, "(curve %s)",
	curvename?curvename:curvestr);
	if (!err)
	{
	j = 0;
	/* Append the public key element Q. */
	put_membuf_str (&mbuf, " _ %m");
	format_args[j++] = pk->pkey + 1;

	/* Append the secret key element D. For ECDH we
	skip PKEY[2] because this holds the KEK which is
	not needed by gpg-agent. */
	i = pk->pubkey_algo == PUBKEY_ALGO_ECDH? 3 : 2;
	if (gcry_mpi_get_flag (pk->pkey[i], GCRYMPI_FLAG_USER1))
	put_membuf_str (&mbuf, " e %m");
	else
	put_membuf_str (&mbuf, " _ %m");
	format_args[j++] = pk->pkey + i;

	/* Simple hack to print a warning for an invalid key
	* in case of cv25519. We have only opaque MPIs here. */
	if (pk->pubkey_algo == PUBKEY_ALGO_ECDH
	&& !strcmp (curvestr, "1.3.6.1.4.1.3029.1.5.1")
	&& !gcry_mpi_get_flag (pk->pkey[i], GCRYMPI_FLAG_USER1)
	&& gcry_mpi_get_flag (pk->pkey[i], GCRYMPI_FLAG_OPAQUE))
	{
	const unsigned char *pp;
	unsigned int nn;

	pp = gcry_mpi_get_opaque (pk->pkey[i], &nn);
	nn = (nn+7)/8;
	if (pp && nn && (pp[nn-1] & 7))
	log_info ("warning: lower 3 bits of the secret key"
	" are not cleared\n");
	}
	}
	xfree (curvestr);
	}
	}
	else
	{
	/* Standard case for the old (non-ECC) algorithms. */
	for (i=j=0; i < nskey; i++)
	{
	if (!pk->pkey[i])
	continue; /* Protected keys only have NPKEY+1 elements. */

	if (gcry_mpi_get_flag (pk->pkey[i], GCRYMPI_FLAG_USER1))
	put_membuf_str (&mbuf, " e %m");
	else
	put_membuf_str (&mbuf, " _ %m");
	format_args[j++] = pk->pkey + i;
	}
	}
	put_membuf_str (&mbuf, ")");
	put_membuf (&mbuf, "", 1);
	if (err)
	xfree (get_membuf (&mbuf, NULL));
	else
	{
	char *format = get_membuf (&mbuf, NULL);
	if (!format)
	err = gpg_error_from_syserror ();
	else
	err = gcry_sexp_build_array (&skey, NULL, format, format_args);
	xfree (format);
	}
	if (err)
	{
	log_error ("error building skey array: %s\n", gpg_strerror (err));
	goto leave;
	}

	if (ski->is_protected)
	{
	char countbuf[35];

	/* FIXME: Support AEAD */
	/* Note that the IVLEN may be zero if we are working on a
	dummy key. We can't express that in an S-expression and
	thus we send dummy data for the IV. */
	snprintf (countbuf, sizeof countbuf, "%lu",
	(unsigned long)ski->s2k.count);
	err = gcry_sexp_build
	(&prot, NULL,
	" (protection %s %s %b %d %s %b %s)\n",
	ski->sha1chk? "sha1":"sum",
	openpgp_cipher_algo_name (ski->algo),
	ski->ivlen? (int)ski->ivlen:1,
	ski->ivlen? ski->iv: (const unsigned char*)"X",
	ski->s2k.mode,
	openpgp_md_algo_name (ski->s2k.hash_algo),
	(int)sizeof (ski->s2k.salt), ski->s2k.salt,
	countbuf);
	}
	else
	err = gcry_sexp_build (&prot, NULL, " (protection none)\n");

	tmpsexp = NULL;
	xfree (transferkey);
	transferkey = NULL;
	if (!err)
	err = gcry_sexp_build (&tmpsexp, NULL,
	"(openpgp-private-key\n"
	" (version %d)\n"
	" (algo %s)\n"
	" %S%S\n"
	" (csum %d)\n"
	" %S)\n",
	pk->version,
	openpgp_pk_algo_name (pk->pubkey_algo),
	curve, skey,
	(int)(unsigned long)ski->csum, prot);
	gcry_sexp_release (skey);
	gcry_sexp_release (prot);
	if (!err)
	err = make_canon_sexp_pad (tmpsexp, 1, &transferkey, &transferkeylen);
	gcry_sexp_release (tmpsexp);
	if (err)
	{
	log_error ("error building transfer key: %s\n", gpg_strerror (err));
	goto leave;
	}

	/* Wrap the key. */
	wrappedkeylen = transferkeylen + 8;
	xfree (wrappedkey);
	wrappedkey = xtrymalloc (wrappedkeylen);
	if (!wrappedkey)
	err = gpg_error_from_syserror ();
	else
	err = gcry_cipher_encrypt (cipherhd, wrappedkey, wrappedkeylen,
	transferkey, transferkeylen);
	if (err)
	goto leave;
	xfree (transferkey);
	transferkey = NULL;

	/* Send the wrapped key to the agent. */
	{
	char *desc = gpg_format_keydesc (ctrl, pk, FORMAT_KEYDESC_IMPORT, 1);
	err = agent_import_key (ctrl, desc, &cache_nonce,
	wrappedkey, wrappedkeylen, batch, force,
	pk->keyid, pk->main_keyid, pk->pubkey_algo,
	pk->timestamp);
	xfree (desc);
	}
	if (!err)
	{
	if (opt.verbose)
	log_info (_("key %s: secret key imported\n"),
	keystr_from_pk_with_sub (main_pk, pk));
	if (stats)
	stats->secret_imported++;
	}
	else if ( gpg_err_code (err) == GPG_ERR_EEXIST )
	{
	if (opt.verbose)
	log_info (_("key %s: secret key already exists\n"),
	keystr_from_pk_with_sub (main_pk, pk));
	err = 0;
	if (stats)
	stats->secret_dups++;
	}
	else
	{
	log_error (_("key %s: error sending to agent: %s\n"),
	keystr_from_pk_with_sub (main_pk, pk),
	gpg_strerror (err));
	if (gpg_err_code (err) == GPG_ERR_CANCELED
	\|\| gpg_err_code (err) == GPG_ERR_FULLY_CANCELED)
	break; /* Don't try the other subkeys. */
	}
	}

	if (!err && stub_key_skipped)
	/* We need to notify user how to migrate stub keys. */
	err = gpg_error (GPG_ERR_NOT_PROCESSED);

	leave:
	gcry_sexp_release (curve);
	xfree (cache_nonce);
	xfree (wrappedkey);
	xfree (transferkey);
	gcry_cipher_close (cipherhd);
	xfree (kek);
	return err;
	}


	/* Walk a secret keyblock and produce a public keyblock out of it.
	* Returns a new node or NULL on error. Modifies the tag field of the
	* nodes. */
	static kbnode_t
	sec_to_pub_keyblock (kbnode_t sec_keyblock)
	{
	kbnode_t pub_keyblock = NULL;
	kbnode_t ctx = NULL;
	kbnode_t secnode, pubnode;
	kbnode_t lastnode = NULL;
	unsigned int tag = 0;

	/* Set a tag to all nodes. */
	for (secnode = sec_keyblock; secnode; secnode = secnode->next)
	secnode->tag = ++tag;

	/* Copy. */
	while ((secnode = walk_kbnode (sec_keyblock, &ctx, 0)))
	{
	if (secnode->pkt->pkttype == PKT_SECRET_KEY
	\|\| secnode->pkt->pkttype == PKT_SECRET_SUBKEY)
	{
	/* Make a public key. */
	PACKET *pkt;
	PKT_public_key *pk;

	pkt = xtrycalloc (1, sizeof *pkt);
	pk = pkt? copy_public_key (NULL, secnode->pkt->pkt.public_key): NULL;
	if (!pk)
	{
	xfree (pkt);
	release_kbnode (pub_keyblock);
	return NULL;
	}
	if (secnode->pkt->pkttype == PKT_SECRET_KEY)
	pkt->pkttype = PKT_PUBLIC_KEY;
	else
	pkt->pkttype = PKT_PUBLIC_SUBKEY;
	pkt->pkt.public_key = pk;

	pubnode = new_kbnode (pkt);
	}
	else
	{
	pubnode = clone_kbnode (secnode);
	}
	pubnode->tag = secnode->tag;

	if (!pub_keyblock)
	pub_keyblock = lastnode = pubnode;
	else
	{
	lastnode->next = pubnode;
	lastnode = pubnode;
	}
	}

	return pub_keyblock;
	}


	/* Delete all notes in the keyblock at R_KEYBLOCK which are not in
	* PUB_KEYBLOCK. Modifies the tags of both keyblock's nodes. */
	static gpg_error_t
	resync_sec_with_pub_keyblock (kbnode_t *r_keyblock, kbnode_t pub_keyblock,
	kbnode_t *r_removedsecs)
	{
	kbnode_t sec_keyblock = *r_keyblock;
	kbnode_t node, prevnode;
	unsigned int *taglist;
	unsigned int ntaglist, n;
	kbnode_t attic = NULL;
	kbnode_t *attic_head = &attic;

	/* Collect all tags in an array for faster searching. */
	for (ntaglist = 0, node = pub_keyblock; node; node = node->next)
	ntaglist++;
	taglist = xtrycalloc (ntaglist, sizeof *taglist);
	if (!taglist)
	return gpg_error_from_syserror ();
	for (ntaglist = 0, node = pub_keyblock; node; node = node->next)
	taglist[ntaglist++] = node->tag;

	/* Walks over the secret keyblock and delete all nodes which are not
	* in the tag list. Those nodes have been deleted in the
	* pub_keyblock. Sequential search is a bit lazy and could be
	* optimized by sorting and bsearch; however secret keyrings are
	* short and there are easier ways to DoS the import. */
	again:
	for (prevnode=NULL, node=sec_keyblock; node; prevnode=node, node=node->next)
	{
	for (n=0; n < ntaglist; n++)
	if (taglist[n] == node->tag)
	break;
	if (n == ntaglist) /* Not in public keyblock. */
	{
	if (node->pkt->pkttype == PKT_SECRET_KEY
	\|\| node->pkt->pkttype == PKT_SECRET_SUBKEY)
	{
	if (!prevnode)
	sec_keyblock = node->next;
	else
	prevnode->next = node->next;
	node->next = NULL;
	*attic_head = node;
	attic_head = &node->next;
	goto again; /* That's lame; I know. */
	}
	else
	delete_kbnode (node);
	}
	}

	xfree (taglist);

	/* Commit the as deleted marked nodes and return the possibly
	* modified keyblock and a list of removed secret key nodes. */
	commit_kbnode (&sec_keyblock);
	*r_keyblock = sec_keyblock;
	*r_removedsecs = attic;
	return 0;
	}


	/* Helper for import_secret_one. */
	static gpg_error_t
	do_transfer (ctrl_t ctrl, kbnode_t keyblock, PKT_public_key *pk,
	struct import_stats_s *stats, int batch, int only_marked)

	{
	gpg_error_t err;
	struct import_stats_s subkey_stats = {0};
	int force = 0;
	int already_exist = agent_probe_secret_key (ctrl, pk);

	if (already_exist == 2 \|\| already_exist == 4)
	{
	if (!opt.quiet)
	log_info (_("key %s: card reference is overridden by key material\n"),
	keystr_from_pk (pk));
	force = 1;
	}

	err = transfer_secret_keys (ctrl, &subkey_stats, keyblock,
	batch, force, only_marked);
	if (gpg_err_code (err) == GPG_ERR_NOT_PROCESSED)
	{
	/* TRANSLATORS: For a smartcard, each private key on host has a
	* reference (stub) to a smartcard and actual private key data
	* is stored on the card. A single smartcard can have up to
	* three private key data. Importing private key stub is always
	* skipped in 2.1, and it returns GPG_ERR_NOT_PROCESSED.
	* Instead, user should be suggested to run 'gpg --card-status',
	* then, references to a card will be automatically created
	* again. */
	log_info (_("To migrate '%s', with each smartcard, "
	"run: %s\n"), "secring.gpg", "gpg --card-status");
	err = 0;
	}

	if (!err)
	{
	int status = 16;

	if (!opt.quiet)
	log_info (_("key %s: secret key imported\n"), keystr_from_pk (pk));
	if (subkey_stats.secret_imported)
	{
	status \|= 1;
	stats->secret_imported += 1;
	}
	if (subkey_stats.secret_dups)
	stats->secret_dups += 1;

	if (is_status_enabled ())
	print_import_ok (pk, status);
	}

	return err;
	}


	/* If the secret keys (main or subkey) in SECKEYS have a corresponding
	* public key in the public key described by (FPR,FPRLEN) import these
	* parts.
	*/
	static gpg_error_t
	import_matching_seckeys (ctrl_t ctrl, kbnode_t seckeys,
	const byte *mainfpr, size_t mainfprlen,
	struct import_stats_s *stats, int batch)
	{
	gpg_error_t err;
	kbnode_t pub_keyblock = NULL;
	kbnode_t node;
	struct { byte fpr[MAX_FINGERPRINT_LEN]; size_t fprlen; } *fprlist = NULL;
	size_t n, nfprlist;
	byte fpr[MAX_FINGERPRINT_LEN];
	size_t fprlen;
	PKT_public_key *pk;

	/* Get the entire public key block from our keystore and put all its
	* fingerprints into an array. */
	err = get_pubkey_byfpr (ctrl, NULL, &pub_keyblock, mainfpr, mainfprlen);
	if (err)
	goto leave;
	log_assert (pub_keyblock && pub_keyblock->pkt->pkttype == PKT_PUBLIC_KEY);
	pk = pub_keyblock->pkt->pkt.public_key;

	for (nfprlist = 0, node = pub_keyblock; node; node = node->next)
	if (node->pkt->pkttype == PKT_PUBLIC_KEY
	\|\| node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
	nfprlist++;
	log_assert (nfprlist);
	fprlist = xtrycalloc (nfprlist, sizeof *fprlist);
	if (!fprlist)
	{
	err = gpg_error_from_syserror ();
	goto leave;
	}
	for (n = 0, node = pub_keyblock; node; node = node->next)
	if (node->pkt->pkttype == PKT_PUBLIC_KEY
	\|\| node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
	{
	fingerprint_from_pk (node->pkt->pkt.public_key,
	fprlist[n].fpr, &fprlist[n].fprlen);
	n++;
	}
	log_assert (n == nfprlist);

	/* for (n=0; n < nfprlist; n++) */
	/* log_printhex (fprlist[n].fpr, fprlist[n].fprlen, "pubkey %zu:", n); */

	/* Mark all secret keys which have a matching public key part in
	* PUB_KEYBLOCK. */
	for (node = seckeys; node; node = node->next)
	{
	if (node->pkt->pkttype != PKT_SECRET_KEY
	&& node->pkt->pkttype != PKT_SECRET_SUBKEY)
	continue; /* Should not happen. */
	fingerprint_from_pk (node->pkt->pkt.public_key, fpr, &fprlen);
	node->flag &= ~NODE_TRANSFER_SECKEY;
	for (n=0; n < nfprlist; n++)
	if (fprlist[n].fprlen == fprlen && !memcmp (fprlist[n].fpr,fpr,fprlen))
	{
	node->flag \|= NODE_TRANSFER_SECKEY;
	/* log_debug ("found matching seckey\n"); */
	break;
	}
	}

	/* Transfer all marked keys. */
	err = do_transfer (ctrl, seckeys, pk, stats, batch, 1);

	leave:
	xfree (fprlist);
	release_kbnode (pub_keyblock);
	return err;
	}


	/* Import function for a single secret keyblock. Handling is simpler
	* than for public keys. We allow secret key importing only when
	* allow is true, this is so that a secret key can not be imported
	* accidentally and thereby tampering with the trust calculation.
	*
	* Ownership of KEYBLOCK is transferred to this function!
	*
	* If R_SECATTIC is not null the last special sec_keyblock is stored
	* there.
	*/
	static gpg_error_t
	import_secret_one (ctrl_t ctrl, kbnode_t keyblock,
	struct import_stats_s *stats, int batch,
	unsigned int options, int for_migration,
	import_screener_t screener, void *screener_arg,
	kbnode_t *r_secattic)
	{
	PKT_public_key *pk;
	struct seckey_info *ski;
	kbnode_t node, uidnode;
	u32 keyid[2];
	gpg_error_t err = 0;
	int nr_prev;
	kbnode_t pub_keyblock;
	kbnode_t attic = NULL;
	byte fpr[MAX_FINGERPRINT_LEN];
	size_t fprlen;
	char pkstrbuf[PUBKEY_STRING_SIZE];

	/* Get the key and print some info about it */
	node = find_kbnode (keyblock, PKT_SECRET_KEY);
	if (!node)
	BUG ();

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

	fingerprint_from_pk (pk, fpr, &fprlen);
	keyid_from_pk (pk, keyid);
	uidnode = find_next_kbnode (keyblock, PKT_USER_ID);

	if (screener && screener (keyblock, screener_arg))
	{
	log_error (_("secret key %s: %s\n"), keystr_from_pk (pk),
	_("rejected by import screener"));
	release_kbnode (keyblock);
	return 0;
	}

	if (opt.verbose && !for_migration)
	{
	log_info ("sec %s/%s %s ",
	pubkey_string (pk, pkstrbuf, sizeof pkstrbuf),
	keystr_from_pk (pk), datestr_from_pk (pk));
	if (uidnode)
	print_utf8_buffer (log_get_stream (), uidnode->pkt->pkt.user_id->name,
	uidnode->pkt->pkt.user_id->len);
	log_printf ("\n");
	}
	stats->secret_read++;

	if ((options & IMPORT_ONLY_PUBKEYS))
	{
	if (!for_migration)
	log_error (_("importing secret keys not allowed\n"));
	release_kbnode (keyblock);
	return 0;
	}

	if (!uidnode)
	{
	if (!for_migration)
	log_error( _("key %s: no user ID\n"), keystr_from_pk (pk));
	release_kbnode (keyblock);
	return 0;
	}

	ski = pk->seckey_info;
	if (!ski)
	{
	/* Actually an internal error. */
	log_error ("key %s: secret key info missing\n", keystr_from_pk (pk));
	release_kbnode (keyblock);
	return 0;
	}

	/* A quick check to not import keys with an invalid protection
	cipher algorithm (only checks the primary key, though). */
	if (ski->algo > 110)
	{
	if (!for_migration)
	log_error (_("key %s: secret key with invalid cipher %d"
	" - skipped\n"), keystr_from_pk (pk), ski->algo);
	release_kbnode (keyblock);
	return 0;
	}

	#ifdef ENABLE_SELINUX_HACKS
	if (1)
	{
	/* We don't allow importing secret keys because that may be used
	to put a secret key into the keyring and the user might later
	be tricked into signing stuff with that key. */
	log_error (_("importing secret keys not allowed\n"));
	release_kbnode (keyblock);
	return 0;
	}
	#endif

	clear_kbnode_flags (keyblock);

	nr_prev = stats->skipped_new_keys;

	/* Make a public key out of the key. */
	pub_keyblock = sec_to_pub_keyblock (keyblock);
	if (!pub_keyblock)
	{
	err = gpg_error_from_syserror ();
	log_error ("key %s: failed to create public key from secret key\n",
	keystr_from_pk (pk));
	}
	else
	{
	int valid;

	/* Note that this outputs an IMPORT_OK status message for the
	public key block, and below we will output another one for
	the secret keys. FIXME? */
	import_one (ctrl, pub_keyblock, stats,
	NULL, NULL, options, 1, for_migration,
	screener, screener_arg, 0, NULL, &valid);

	/* The secret keyblock may not have nodes which are deleted in
	* the public keyblock. Otherwise we would import just the
	* secret key without having the public key. That would be
	* surprising and clutters our private-keys-v1.d. */
	err = resync_sec_with_pub_keyblock (&keyblock, pub_keyblock, &attic);
	if (err)
	goto leave;

	if (!valid)
	{
	/* If the block was not valid the primary key is left in the
	* original keyblock because we require that for the first
	* node. Move it to ATTIC. */
	if (keyblock && keyblock->pkt->pkttype == PKT_SECRET_KEY)
	{
	node = keyblock;
	keyblock = node->next;
	node->next = NULL;
	if (attic)
	{
	node->next = attic;
	attic = node;
	}
	else
	attic = node;
	}

	/* Try to import the secret key iff we have a public key. */
	if (attic && !(opt.dry_run \|\| (options & IMPORT_DRY_RUN)))
	err = import_matching_seckeys (ctrl, attic, fpr, fprlen,
	stats, batch);
	else
	err = gpg_error (GPG_ERR_NO_SECKEY);
	goto leave;
	}

	/* log_debug ("attic is:\n"); */
	/* dump_kbnode (attic); */

	/* Proceed with the valid parts of PUBKEYBLOCK. */

	/* At least we cancel the secret key import when the public key
	import was skipped due to MERGE_ONLY option and a new
	key. */
	if (!(opt.dry_run \|\| (options & IMPORT_DRY_RUN))
	&& stats->skipped_new_keys <= nr_prev)
	{
	/* Read the keyblock again to get the effects of a merge for
	* the public key. */
	err = get_pubkey_byfpr (ctrl, NULL, &node, fpr, fprlen);
	if (err \|\| !node)
	log_error ("key %s: failed to re-lookup public key: %s\n",
	keystr_from_pk (pk), gpg_strerror (err));
	else
	{
	err = do_transfer (ctrl, keyblock, pk, stats, batch, 0);
	if (!err)
	check_prefs (ctrl, node);
	release_kbnode (node);

	if (!err && attic)
	{
	/* Try to import invalid subkeys. This can be the
	* case if the primary secret key was imported due
	* to --allow-non-selfsigned-uid. */
	err = import_matching_seckeys (ctrl, attic, fpr, fprlen,
	stats, batch);
	}

	}
	}
	}

	leave:
	release_kbnode (keyblock);
	release_kbnode (pub_keyblock);
	if (r_secattic)
	*r_secattic = attic;
	else
	release_kbnode (attic);
	return err;
	}


	/* Return a string for the revocation reason CODE. R_FREEM must be an
	* possibly unintialized ptr which should be freed by the caller after
	* the return value has been consumed. */
	const char *
	revocation_reason_code_to_str (int code, char **freeme)
	{
	/* Take care: get_revocation_reason has knowledge of the internal
	* working of this fucntion. */
	const char *result;

	*freeme = NULL;
	switch (code)
	{
	case 0x00: result = _("No reason specified"); break;
	case 0x01: result = _("Key is superseded"); break;
	case 0x02: result = _("Key has been compromised"); break;
	case 0x03: result = _("Key is no longer used"); break;
	case 0x20: result = _("User ID is no longer valid"); break;
	default:
	*freeme = xasprintf ("code=%02x", code);
	result = *freeme;
	break;
	}

	return result;
	}


	/* Return the recocation reason from signature SIG. If no revocation
	* reason is available 0 is returned, in other cases the reason
	* (0..255). If R_REASON is not NULL a malloced textual
	* representation of the code is stored there. If R_COMMENT is not
	* NULL the comment from the reason is stored there and its length at
	* R_COMMENTLEN. Note that the value at R_COMMENT is not filtered but
	* user supplied data in UTF8; thus it needs to be escaped for display
	* purposes. Both return values are either NULL or a malloced
	* string/buffer. */
	int
	get_revocation_reason (PKT_signature sig, char *r_reason,
	char *r_comment, size_t r_commentlen)
	{
	int reason_seq = 0;
	size_t reason_n;
	const byte *reason_p;
	int reason_code = 0;
	const char *reason_string;
	char *freeme;

	if (r_reason)
	*r_reason = NULL;
	if (r_comment)
	*r_comment = NULL;

	/* Skip over empty reason packets. */
	while ((reason_p = enum_sig_subpkt (sig, 1, SIGSUBPKT_REVOC_REASON,
	&reason_n, &reason_seq, NULL))
	&& !reason_n)
	;
	if (reason_p && reason_n)
	{
	reason_code = *reason_p;
	reason_n--; reason_p++;
	reason_string = revocation_reason_code_to_str (reason_code, &freeme);
	if (r_reason && freeme)
	*r_reason = freeme;
	else if (r_reason && reason_string)
	*r_reason = xstrdup (reason_string);
	else
	xfree (freeme);

	if (r_comment && reason_n)
	{
	*r_comment = xmalloc (reason_n);
	memcpy (*r_comment, reason_p, reason_n);
	*r_commentlen = reason_n;
	}
	}

	return reason_code;
	}


	/* List the recocation signature as a "rvs" record. SIGRC shows the
	* character from the signature verification or 0 if no public key was
	* found. */
	static void
	list_standalone_revocation (ctrl_t ctrl, PKT_signature *sig, int sigrc)
	{
	char *siguid = NULL;
	size_t siguidlen = 0;
	char *issuer_fpr = NULL;
	int reason_code = 0;
	char *reason_text = NULL;
	char *reason_comment = NULL;
	size_t reason_commentlen;

	if (sigrc != '%' && sigrc != '?' && !opt.fast_list_mode)
	{
	int nouid;
	siguid = get_user_id (ctrl, sig->keyid, &siguidlen, &nouid);
	if (nouid)
	sigrc = '?';
	}

	reason_code = get_revocation_reason (sig, &reason_text,
	&reason_comment, &reason_commentlen);

	if (opt.with_colons)
	{
	es_fputs ("rvs:", es_stdout);
	if (sigrc)
	es_putc (sigrc, es_stdout);
	es_fprintf (es_stdout, "::%d:%08lX%08lX:%s:%s:::",
	sig->pubkey_algo,
	(ulong) sig->keyid[0], (ulong) sig->keyid[1],
	colon_datestr_from_sig (sig),
	colon_expirestr_from_sig (sig));

	if (siguid)
	es_write_sanitized (es_stdout, siguid, siguidlen, ":", NULL);

	es_fprintf (es_stdout, ":%02x%c", sig->sig_class,
	sig->flags.exportable ? 'x' : 'l');
	if (reason_text)
	es_fprintf (es_stdout, ",%02x", reason_code);
	es_fputs ("::", es_stdout);

	if ((issuer_fpr = issuer_fpr_string (sig)))
	es_fputs (issuer_fpr, es_stdout);

	es_fprintf (es_stdout, ":::%d:", sig->digest_algo);

	if (reason_comment)
	{
	es_fputs ("::::", es_stdout);
	es_write_sanitized (es_stdout, reason_comment, reason_commentlen,
	":", NULL);
	es_putc (':', es_stdout);
	}
	es_putc ('\n', es_stdout);

	if (opt.show_subpackets)
	print_subpackets_colon (sig);
	}
	else /* Human readable. */
	{
	es_fputs ("rvs", es_stdout);
	es_fprintf (es_stdout, "%c%c %c%c%c%c%c%c %s %s",
	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 (siguid)
	{
	es_fprintf (es_stdout, " ");
	print_utf8_buffer (es_stdout, siguid, siguidlen);
	}
	es_putc ('\n', es_stdout);

	if (sig->flags.policy_url
	&& (opt.list_options & LIST_SHOW_POLICY_URLS))
	show_policy_url (sig, 3, 0);

	if (sig->flags.notation && (opt.list_options & LIST_SHOW_NOTATIONS))
	show_notation (sig, 3, 0,
	((opt.list_options & LIST_SHOW_STD_NOTATIONS) ? 1 : 0)
	+
	((opt.list_options & LIST_SHOW_USER_NOTATIONS) ? 2 : 0)
	+
	((opt.list_options & LIST_SHOW_HIDDEN_NOTATIONS) ? 4:0));

	if (sig->flags.pref_ks
	&& (opt.list_options & LIST_SHOW_KEYSERVER_URLS))
	show_keyserver_url (sig, 3, 0);

	if (reason_text)
	{
	es_fprintf (es_stdout, " %s%s\n",
	_("reason for revocation: "), reason_text);
	print_revocation_reason_comment (reason_comment, reason_commentlen);
	}
	}

	es_fflush (es_stdout);

	xfree (reason_text);
	xfree (reason_comment);
	xfree (siguid);
	xfree (issuer_fpr);
	}


	/* Import a revocation certificate; only the first packet in the
	* NODE-list is considered. */
	static int
	import_revoke_cert (ctrl_t ctrl, kbnode_t node, unsigned int options,
	struct import_stats_s *stats)
	{
	PKT_public_key *pk = NULL;
	kbnode_t onode;
	kbnode_t keyblock = NULL;
	KEYDB_HANDLE hd = NULL;
	u32 keyid[2];
	int rc = 0;
	int sigrc = 0;
	int silent;

	/* No error output for --show-keys. */
	silent = (options & (IMPORT_SHOW \| IMPORT_DRY_RUN));

	log_assert (node->pkt->pkttype == PKT_SIGNATURE );
	log_assert (IS_KEY_REV (node->pkt->pkt.signature));

	/* FIXME: We can do better here by using the issuer fingerprint if
	* available. We should also make use of get_keyblock_byfprint_fast. */

	keyid[0] = node->pkt->pkt.signature->keyid[0];
	keyid[1] = node->pkt->pkt.signature->keyid[1];

	pk = xmalloc_clear( sizeof *pk );
	rc = get_pubkey (ctrl, pk, keyid );
	if (gpg_err_code (rc) == GPG_ERR_NO_PUBKEY )
	{
	if (!silent)
	log_error (_("key %s: no public key -"
	" can't apply revocation certificate\n"), keystr(keyid));
	rc = 0;
	goto leave;
	}
	else if (rc )
	{
	log_error (_("key %s: public key not found: %s\n"),
	keystr(keyid), gpg_strerror (rc));
	goto leave;
	}

	/* Read the original keyblock. */
	hd = keydb_new (ctrl);
	if (!hd)
	{
	rc = gpg_error_from_syserror ();
	goto leave;
	}

	+ rc = keydb_lock (hd);
	+ if (rc)
	+ {
	+ keydb_release (hd);
	+ goto leave;
	+ }
	+
	{
	byte afp[MAX_FINGERPRINT_LEN];
	size_t an;

	fingerprint_from_pk (pk, afp, &an);
	rc = keydb_search_fpr (hd, afp, an);
	}
	if (rc)
	{
	log_error (_("key %s: can't locate original keyblock: %s\n"),
	keystr(keyid), gpg_strerror (rc));
	goto leave;
	}
	rc = keydb_get_keyblock (hd, &keyblock );
	if (rc)
	{
	log_error (_("key %s: can't read original keyblock: %s\n"),
	keystr(keyid), gpg_strerror (rc));
	goto leave;
	}

	/* it is okay, that node is not in keyblock because
	* check_key_signature works fine for sig_class 0x20 (KEY_REV) in
	* this special case. SIGRC is only used for IMPORT_SHOW. */
	rc = check_key_signature (ctrl, keyblock, node, NULL);
	switch (gpg_err_code (rc))
	{
	case 0: sigrc = '!'; break;
	case GPG_ERR_BAD_SIGNATURE: sigrc = '-'; break;
	case GPG_ERR_NO_PUBKEY: sigrc = '?'; break;
	case GPG_ERR_UNUSABLE_PUBKEY: sigrc = '?'; break;
	default: sigrc = '%'; break;
	}
	if (rc )
	{
	if (!silent)
	log_error (_("key %s: invalid revocation certificate"
	": %s - rejected\n"), keystr(keyid), gpg_strerror (rc));
	goto leave;
	}

	/* check whether we already have this */
	for(onode=keyblock->next; onode; onode=onode->next ) {
	if (onode->pkt->pkttype == PKT_USER_ID )
	break;
	else if (onode->pkt->pkttype == PKT_SIGNATURE
	&& !cmp_signatures(node->pkt->pkt.signature,
	onode->pkt->pkt.signature))
	{
	rc = 0;
	goto leave; /* yes, we already know about it */
	}
	}

	/* insert it */
	insert_kbnode( keyblock, clone_kbnode(node), 0 );

	/* and write the keyblock back unless in dry run mode. */
	if (!(opt.dry_run \|\| (options & IMPORT_DRY_RUN)))
	{
	rc = keydb_update_keyblock (ctrl, hd, keyblock );
	if (rc)
	log_error (_("error writing keyring '%s': %s\n"),
	keydb_get_resource_name (hd), gpg_strerror (rc) );
	keydb_release (hd);
	hd = NULL;

	/* we are ready */
	if (!opt.quiet )
	{
	char *p=get_user_id_native (ctrl, keyid);
	log_info( _("key %s: \"%s\" revocation certificate imported\n"),
	keystr(keyid),p);
	xfree(p);
	}

	/* If the key we just revoked was ultimately trusted, remove its
	* ultimate trust. This doesn't stop the user from putting the
	* ultimate trust back, but is a reasonable solution for now. */
	if (get_ownertrust (ctrl, pk) == TRUST_ULTIMATE)
	clear_ownertrusts (ctrl, pk);

	revalidation_mark (ctrl);
	}
	stats->n_revoc++;

	leave:
	if ((options & IMPORT_SHOW))
	list_standalone_revocation (ctrl, node->pkt->pkt.signature, sigrc);

	keydb_release (hd);
	release_kbnode( keyblock );
	free_public_key( pk );
	return rc;
	}


	/* Loop over the KEYBLOCK and check all self signatures. KEYID is the
	* keyid of the primary key for reporting purposes. On return the
	* following bits in the node flags are set:
	*
	* - NODE_GOOD_SELFSIG :: User ID or subkey has a self-signature
	* - NODE_BAD_SELFSIG :: Used ID or subkey has an invalid self-signature
	* - NODE_DELETION_MARK :: This node shall be deleted
	*
	* NON_SELF is set to true if there are any sigs other than self-sigs
	* in this keyblock.
	*
	* Returns 0 on success or -1 (but not an error code) if the keyblock
	* is invalid.
	*/
	static int
	chk_self_sigs (ctrl_t ctrl, kbnode_t keyblock, u32 keyid, int non_self)
	{
	kbnode_t knode = NULL; /* The node of the current subkey. */
	PKT_public_key subpk = NULL; / and its packet. */
	kbnode_t bsnode = NULL; /* Subkey binding signature node. */
	u32 bsdate = 0; /* Timestamp of that node. */
	kbnode_t rsnode = NULL; /* Subkey recocation signature node. */
	u32 rsdate = 0; /* Timestamp of that node. */
	PKT_signature *sig;
	int rc;
	kbnode_t n;

	for (n=keyblock; (n = find_next_kbnode (n, 0)); )
	{
	if (n->pkt->pkttype == PKT_PUBLIC_SUBKEY)
	{
	knode = n;
	subpk = knode->pkt->pkt.public_key;
	bsdate = 0;
	rsdate = 0;
	bsnode = NULL;
	rsnode = NULL;
	continue;
	}

	if ( n->pkt->pkttype != PKT_SIGNATURE )
	continue;

	sig = n->pkt->pkt.signature;
	if ( keyid[0] != sig->keyid[0] \|\| keyid[1] != sig->keyid[1] )
	{
	*non_self = 1;
	continue;
	}

	/* This just caches the sigs for later use. That way we
	import a fully-cached key which speeds things up. */
	if (!opt.no_sig_cache)
	check_key_signature (ctrl, keyblock, n, NULL);

	if ( IS_UID_SIG(sig) \|\| IS_UID_REV(sig) )
	{
	kbnode_t unode = find_prev_kbnode( keyblock, n, PKT_USER_ID );
	if ( !unode )
	{
	log_error( _("key %s: no user ID for signature\n"),
	keystr(keyid));
	return -1; /* The complete keyblock is invalid. */
	}

	/* If it hasn't been marked valid yet, keep trying. */
	if (!(unode->flag & NODE_GOOD_SELFSIG))
	{
	rc = check_key_signature (ctrl, keyblock, n, NULL);
	if ( rc )
	{
	if ( opt.verbose )
	{
	char *p = utf8_to_native
	(unode->pkt->pkt.user_id->name,
	strlen (unode->pkt->pkt.user_id->name),0);
	log_info (gpg_err_code(rc) == GPG_ERR_PUBKEY_ALGO ?
	_("key %s: unsupported public key "
	"algorithm on user ID \"%s\"\n"):
	_("key %s: invalid self-signature "
	"on user ID \"%s\"\n"),
	keystr (keyid),p);
	xfree (p);
	}
	}
	else
	unode->flag \|= NODE_GOOD_SELFSIG;
	}
	}
	else if (IS_KEY_SIG (sig))
	{
	rc = check_key_signature (ctrl, keyblock, n, NULL);
	if ( rc )
	{
	if (opt.verbose)
	log_info (gpg_err_code (rc) == GPG_ERR_PUBKEY_ALGO ?
	_("key %s: unsupported public key algorithm\n"):
	_("key %s: invalid direct key signature\n"),
	keystr (keyid));
	n->flag \|= NODE_DELETION_MARK;
	}
	}
	else if ( IS_SUBKEY_SIG (sig) )
	{
	/* Note that this works based solely on the timestamps like
	the rest of gpg. If the standard gets revocation
	targets, this may need to be revised. */

	if ( !knode )
	{
	if (opt.verbose)
	log_info (_("key %s: no subkey for key binding\n"),
	keystr (keyid));
	n->flag \|= NODE_DELETION_MARK;
	}
	else
	{
	rc = check_key_signature (ctrl, keyblock, n, NULL);
	if ( rc )
	{
	if (opt.verbose)
	{
	keyid_from_pk (subpk, NULL);
	log_info (gpg_err_code (rc) == GPG_ERR_PUBKEY_ALGO ?
	_("key %s: unsupported public key"
	" algorithm\n"):
	_("key %s: invalid subkey binding\n"),
	keystr_with_sub (keyid, subpk->keyid));
	}
	n->flag \|= NODE_DELETION_MARK;
	}
	else
	{
	/* It's valid, so is it newer? */
	if (sig->timestamp >= bsdate)
	{
	knode->flag \|= NODE_GOOD_SELFSIG; /* Subkey is valid. */
	if (bsnode)
	{
	/* Delete the last binding sig since this
	one is newer */
	bsnode->flag \|= NODE_DELETION_MARK;
	if (opt.verbose)
	{
	keyid_from_pk (subpk, NULL);
	log_info (_("key %s: removed multiple subkey"
	" binding\n"),
	keystr_with_sub (keyid, subpk->keyid));
	}
	}

	bsnode = n;
	bsdate = sig->timestamp;
	}
	else
	n->flag \|= NODE_DELETION_MARK; /* older */
	}
	}
	}
	else if ( IS_SUBKEY_REV (sig) )
	{
	/* We don't actually mark the subkey as revoked right now,
	so just check that the revocation sig is the most recent
	valid one. Note that we don't care if the binding sig is
	newer than the revocation sig. See the comment in
	getkey.c:merge_selfsigs_subkey for more. */
	if ( !knode )
	{
	if (opt.verbose)
	log_info (_("key %s: no subkey for key revocation\n"),
	keystr(keyid));
	n->flag \|= NODE_DELETION_MARK;
	}
	else
	{
	rc = check_key_signature (ctrl, keyblock, n, NULL);
	if ( rc )
	{
	if(opt.verbose)
	log_info (gpg_err_code (rc) == GPG_ERR_PUBKEY_ALGO ?
	_("key %s: unsupported public"
	" key algorithm\n"):
	_("key %s: invalid subkey revocation\n"),
	keystr(keyid));
	n->flag \|= NODE_DELETION_MARK;
	}
	else
	{
	/* It's valid, so is it newer? */
	if (sig->timestamp >= rsdate)
	{
	if (rsnode)
	{
	/* Delete the last revocation sig since
	this one is newer. */
	rsnode->flag \|= NODE_DELETION_MARK;
	if (opt.verbose)
	log_info (_("key %s: removed multiple subkey"
	" revocation\n"),keystr(keyid));
	}

	rsnode = n;
	rsdate = sig->timestamp;
	}
	else
	n->flag \|= NODE_DELETION_MARK; /* older */
	}
	}
	}
	}

	return 0;
	}


	/* Delete all parts which are invalid and those signatures whose
	* public key algorithm is not available in this implementation; but
	* consider RSA as valid, because parse/build_packets knows about it.
	* If R_OTHERREVSIGS is not NULL, it is used to return a list of
	* revocation certificates which have been deleted from KEYBLOCK but
	* should be handled later.
	*
	* Returns: True if at least one valid user-id is left over.
	*/
	static int
	delete_inv_parts (ctrl_t ctrl, kbnode_t keyblock, u32 *keyid,
	unsigned int options, kbnode_t *r_otherrevsigs)
	{
	kbnode_t node;
	int nvalid=0, uid_seen=0, subkey_seen=0;
	PKT_public_key *pk;

	for (node=keyblock->next; node; node = node->next )
	{
	if (node->pkt->pkttype == PKT_USER_ID)
	{
	uid_seen = 1;
	if ((node->flag & NODE_BAD_SELFSIG)
	\|\| !(node->flag & NODE_GOOD_SELFSIG))
	{
	if (opt.verbose )
	{
	char *p=utf8_to_native(node->pkt->pkt.user_id->name,
	node->pkt->pkt.user_id->len,0);
	log_info( _("key %s: skipped user ID \"%s\"\n"),
	keystr(keyid),p);
	xfree(p);
	}
	delete_kbnode( node ); /* the user-id */
	/* and all following packets up to the next user-id */
	while (node->next
	&& node->next->pkt->pkttype != PKT_USER_ID
	&& node->next->pkt->pkttype != PKT_PUBLIC_SUBKEY
	&& node->next->pkt->pkttype != PKT_SECRET_SUBKEY ){
	delete_kbnode( node->next );
	node = node->next;
	}
	}
	else
	nvalid++;
	}
	else if ( node->pkt->pkttype == PKT_PUBLIC_SUBKEY
	\|\| node->pkt->pkttype == PKT_SECRET_SUBKEY )
	{
	if ((node->flag & NODE_BAD_SELFSIG)
	\|\| !(node->flag & NODE_GOOD_SELFSIG))
	{
	if (opt.verbose )
	{
	pk = node->pkt->pkt.public_key;
	keyid_from_pk (pk, NULL);
	log_info (_("key %s: skipped subkey\n"),
	keystr_with_sub (keyid, pk->keyid));
	}

	delete_kbnode( node ); /* the subkey */
	/* and all following signature packets */
	while (node->next
	&& node->next->pkt->pkttype == PKT_SIGNATURE ) {
	delete_kbnode( node->next );
	node = node->next;
	}
	}
	else
	subkey_seen = 1;
	}
	else if (node->pkt->pkttype == PKT_SIGNATURE
	&& openpgp_pk_test_algo (node->pkt->pkt.signature->pubkey_algo)
	&& node->pkt->pkt.signature->pubkey_algo != PUBKEY_ALGO_RSA )
	{
	delete_kbnode( node ); /* build_packet() can't handle this */
	}
	else if (node->pkt->pkttype == PKT_SIGNATURE
	&& !node->pkt->pkt.signature->flags.exportable
	&& !(options&IMPORT_LOCAL_SIGS)
	&& !have_secret_key_with_kid (ctrl,
	node->pkt->pkt.signature->keyid))
	{
	/* here we violate the rfc a bit by still allowing
	* to import non-exportable signature when we have the
	* the secret key used to create this signature - it
	* seems that this makes sense */
	if(opt.verbose)
	log_info( _("key %s: non exportable signature"
	" (class 0x%02X) - skipped\n"),
	keystr(keyid), node->pkt->pkt.signature->sig_class );
	delete_kbnode( node );
	}
	else if (node->pkt->pkttype == PKT_SIGNATURE
	&& IS_KEY_REV (node->pkt->pkt.signature))
	{
	if (uid_seen )
	{
	if(opt.verbose)
	log_info( _("key %s: revocation certificate"
	" at wrong place - skipped\n"),keystr(keyid));
	if (r_otherrevsigs)
	{
	PACKET *pkt;

	pkt = xcalloc (1, sizeof *pkt);
	pkt->pkttype = PKT_SIGNATURE;
	pkt->pkt.signature = copy_signature
	(NULL, node->pkt->pkt.signature);
	r_otherrevsigs = new_kbnode2 (r_otherrevsigs, pkt);
	}
	delete_kbnode( node );
	}
	else
	{
	/* If the revocation cert is from a different key than
	the one we're working on don't check it - it's
	probably from a revocation key and won't be
	verifiable with this key anyway. */

	if(node->pkt->pkt.signature->keyid[0]==keyid[0]
	&& node->pkt->pkt.signature->keyid[1]==keyid[1])
	{
	int rc = check_key_signature (ctrl, keyblock, node, NULL);
	if (rc )
	{
	if(opt.verbose)
	log_info( _("key %s: invalid revocation"
	" certificate: %s - skipped\n"),
	keystr(keyid), gpg_strerror (rc));
	delete_kbnode( node );
	}
	}
	else if (r_otherrevsigs)
	{
	PACKET *pkt;

	pkt = xcalloc (1, sizeof *pkt);
	pkt->pkttype = PKT_SIGNATURE;
	pkt->pkt.signature = copy_signature
	(NULL, node->pkt->pkt.signature);
	r_otherrevsigs = new_kbnode2 (r_otherrevsigs, pkt);
	}
	}
	}
	else if (node->pkt->pkttype == PKT_SIGNATURE
	&& (IS_SUBKEY_SIG (node->pkt->pkt.signature)
	\|\| IS_SUBKEY_REV (node->pkt->pkt.signature))
	&& !subkey_seen )
	{
	if(opt.verbose)
	log_info( _("key %s: subkey signature"
	" in wrong place - skipped\n"), keystr(keyid));
	delete_kbnode( node );
	}
	else if (node->pkt->pkttype == PKT_SIGNATURE
	&& !IS_CERT(node->pkt->pkt.signature))
	{
	if(opt.verbose)
	log_info(_("key %s: unexpected signature class (0x%02X) -"
	" skipped\n"),keystr(keyid),
	node->pkt->pkt.signature->sig_class);
	delete_kbnode(node);
	}
	else if ((node->flag & NODE_DELETION_MARK))
	delete_kbnode( node );
	}

	/* note: because keyblock is the public key, it is never marked
	* for deletion and so keyblock cannot change */
	commit_kbnode( &keyblock );
	return nvalid;
	}

	/* This function returns true if any UID is left in the keyring. */
	static int
	any_uid_left (kbnode_t keyblock)
	{
	kbnode_t node;

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


	/* Delete all non-self-sigs from KEYBLOCK.
	* Returns: True if the keyblock has changed. */
	static void
	remove_all_non_self_sigs (kbnode_t keyblock, u32 keyid)
	{
	kbnode_t node;
	unsigned int dropped = 0;

	for (node = *keyblock; node; node = node->next)
	{
	if (is_deleted_kbnode (node))
	continue;

	if (node->pkt->pkttype != PKT_SIGNATURE)
	continue;

	if (node->pkt->pkt.signature->keyid[0] == keyid[0]
	&& node->pkt->pkt.signature->keyid[1] == keyid[1])
	continue;
	delete_kbnode (node);
	dropped++;
	}

	if (dropped)
	commit_kbnode (keyblock);

	if (dropped && opt.verbose)
	log_info ("key %s: number of dropped non-self-signatures: %u\n",
	keystr (keyid), dropped);
	}


	/*
	* It may happen that the imported keyblock has duplicated user IDs.
	* We check this here and collapse those user IDs together with their
	* sigs into one.
	* Returns: True if the keyblock has changed.
	*/
	int
	collapse_uids (kbnode_t *keyblock)
	{
	kbnode_t uid1;
	int any=0;

	for(uid1=*keyblock;uid1;uid1=uid1->next)
	{
	kbnode_t uid2;

	if(is_deleted_kbnode(uid1))
	continue;

	if(uid1->pkt->pkttype!=PKT_USER_ID)
	continue;

	for(uid2=uid1->next;uid2;uid2=uid2->next)
	{
	if(is_deleted_kbnode(uid2))
	continue;

	if(uid2->pkt->pkttype!=PKT_USER_ID)
	continue;

	if(cmp_user_ids(uid1->pkt->pkt.user_id,
	uid2->pkt->pkt.user_id)==0)
	{
	/* We have a duplicated uid */
	kbnode_t sig1,last;

	any=1;

	/* Now take uid2's signatures, and attach them to
	uid1 */
	for(last=uid2;last->next;last=last->next)
	{
	if(is_deleted_kbnode(last))
	continue;

	if(last->next->pkt->pkttype==PKT_USER_ID
	\|\| last->next->pkt->pkttype==PKT_PUBLIC_SUBKEY
	\|\| last->next->pkt->pkttype==PKT_SECRET_SUBKEY)
	break;
	}

	/* Snip out uid2 */
	(find_prev_kbnode(*keyblock,uid2,0))->next=last->next;

	/* Now put uid2 in place as part of uid1 */
	last->next=uid1->next;
	uid1->next=uid2;
	delete_kbnode(uid2);

	/* Now dedupe uid1 */
	for(sig1=uid1->next;sig1;sig1=sig1->next)
	{
	kbnode_t sig2;

	if(is_deleted_kbnode(sig1))
	continue;

	if(sig1->pkt->pkttype==PKT_USER_ID
	\|\| sig1->pkt->pkttype==PKT_PUBLIC_SUBKEY
	\|\| sig1->pkt->pkttype==PKT_SECRET_SUBKEY)
	break;

	if(sig1->pkt->pkttype!=PKT_SIGNATURE)
	continue;

	for(sig2=sig1->next,last=sig1;sig2;last=sig2,sig2=sig2->next)
	{
	if(is_deleted_kbnode(sig2))
	continue;

	if(sig2->pkt->pkttype==PKT_USER_ID
	\|\| sig2->pkt->pkttype==PKT_PUBLIC_SUBKEY
	\|\| sig2->pkt->pkttype==PKT_SECRET_SUBKEY)
	break;

	if(sig2->pkt->pkttype!=PKT_SIGNATURE)
	continue;

	if(cmp_signatures(sig1->pkt->pkt.signature,
	sig2->pkt->pkt.signature)==0)
	{
	/* We have a match, so delete the second
	signature */
	delete_kbnode(sig2);
	sig2=last;
	}
	}
	}
	}
	}
	}

	commit_kbnode(keyblock);

	if(any && !opt.quiet)
	{
	const char *key="???";

	if ((uid1 = find_kbnode (*keyblock, PKT_PUBLIC_KEY)) )
	key = keystr_from_pk (uid1->pkt->pkt.public_key);
	else if ((uid1 = find_kbnode( *keyblock, PKT_SECRET_KEY)) )
	key = keystr_from_pk (uid1->pkt->pkt.public_key);

	log_info (_("key %s: duplicated user ID detected - merged\n"), key);
	}

	return any;
	}


	/*
	* It may happen that the imported keyblock has duplicated subkeys.
	* We check this here and collapse those subkeys along with their
	* binding self-signatures.
	* Returns: True if the keyblock has changed.
	*/
	int
	collapse_subkeys (kbnode_t *keyblock)
	{
	kbnode_t kb1, kb2, sig1, sig2, last;
	int any = 0;

	for (kb1 = *keyblock; kb1; kb1 = kb1->next)
	{
	if (is_deleted_kbnode (kb1))
	continue;

	if (kb1->pkt->pkttype != PKT_PUBLIC_SUBKEY
	&& kb1->pkt->pkttype != PKT_SECRET_SUBKEY)
	continue;

	/* We assume just a few duplicates and use a straightforward
	* algorithm. */
	for (kb2 = kb1->next; kb2; kb2 = kb2->next)
	{
	if (is_deleted_kbnode (kb2))
	continue;

	if (kb2->pkt->pkttype != PKT_PUBLIC_SUBKEY
	&& kb2->pkt->pkttype != PKT_SECRET_SUBKEY)
	continue;

	if (cmp_public_keys (kb1->pkt->pkt.public_key,
	kb2->pkt->pkt.public_key))
	continue;

	/* We have a duplicated subkey. */
	any = 1;

	/* Take subkey-2's signatures, and attach them to subkey-1. */
	for (last = kb2; last->next; last = last->next)
	{
	if (is_deleted_kbnode (last))
	continue;

	if (last->next->pkt->pkttype != PKT_SIGNATURE)
	break;
	}

	/* Snip out subkye-2 */
	find_prev_kbnode (*keyblock, kb2, 0)->next = last->next;

	/* Put subkey-2 in place as part of subkey-1 */
	last->next = kb1->next;
	kb1->next = kb2;
	delete_kbnode (kb2);

	/* Now dedupe kb1 */
	for (sig1 = kb1->next; sig1; sig1 = sig1->next)
	{
	if (is_deleted_kbnode (sig1))
	continue;

	if (sig1->pkt->pkttype != PKT_SIGNATURE)
	break;

	for (sig2 = sig1->next, last = sig1;
	sig2;
	last = sig2, sig2 = sig2->next)
	{
	if (is_deleted_kbnode (sig2))
	continue;

	if (sig2->pkt->pkttype != PKT_SIGNATURE)
	break;

	if (!cmp_signatures (sig1->pkt->pkt.signature,
	sig2->pkt->pkt.signature))
	{
	/* We have a match, so delete the second
	signature */
	delete_kbnode (sig2);
	sig2 = last;
	}
	}
	}
	}
	}

	commit_kbnode (keyblock);

	if (any && !opt.quiet)
	{
	const char *key="???";

	if ((kb1 = find_kbnode (*keyblock, PKT_PUBLIC_KEY)) )
	key = keystr_from_pk (kb1->pkt->pkt.public_key);
	else if ((kb1 = find_kbnode (*keyblock, PKT_SECRET_KEY)) )
	key = keystr_from_pk (kb1->pkt->pkt.public_key);

	log_info (_("key %s: duplicated subkeys detected - merged\n"), key);
	}

	return any;
	}


	/* Check for a 0x20 revocation from a revocation key that is not
	present. This may be called without the benefit of merge_xxxx so
	you can't rely on pk->revkey and friends. */
	static void
	revocation_present (ctrl_t ctrl, kbnode_t keyblock)
	{
	kbnode_t onode, inode;
	PKT_public_key *pk = keyblock->pkt->pkt.public_key;

	for(onode=keyblock->next;onode;onode=onode->next)
	{
	/* If we reach user IDs, we're done. */
	if(onode->pkt->pkttype==PKT_USER_ID)
	break;

	if (onode->pkt->pkttype == PKT_SIGNATURE
	&& IS_KEY_SIG (onode->pkt->pkt.signature)
	&& onode->pkt->pkt.signature->revkey)
	{
	int idx;
	PKT_signature *sig=onode->pkt->pkt.signature;

	for(idx=0;idx<sig->numrevkeys;idx++)
	{
	u32 keyid[2];

	keyid_from_fingerprint (ctrl, sig->revkey[idx].fpr,
	sig->revkey[idx].fprlen, keyid);

	for(inode=keyblock->next;inode;inode=inode->next)
	{
	/* If we reach user IDs, we're done. */
	if(inode->pkt->pkttype==PKT_USER_ID)
	break;

	if (inode->pkt->pkttype == PKT_SIGNATURE
	&& IS_KEY_REV (inode->pkt->pkt.signature)
	&& inode->pkt->pkt.signature->keyid[0]==keyid[0]
	&& inode->pkt->pkt.signature->keyid[1]==keyid[1])
	{
	/* Okay, we have a revocation key, and a
	* revocation issued by it. Do we have the key
	* itself? */
	gpg_error_t err;

	err = get_pubkey_byfpr_fast (ctrl, NULL,
	sig->revkey[idx].fpr,
	sig->revkey[idx].fprlen);
	if (gpg_err_code (err) == GPG_ERR_NO_PUBKEY
	\|\| gpg_err_code (err) == GPG_ERR_UNUSABLE_PUBKEY)
	{
	char *tempkeystr = xstrdup (keystr_from_pk (pk));

	/* No, so try and get it */
	if ((opt.keyserver_options.options
	& KEYSERVER_AUTO_KEY_RETRIEVE)
	&& keyserver_any_configured (ctrl))
	{
	log_info(_("WARNING: key %s may be revoked:"
	" fetching revocation key %s\n"),
	tempkeystr,keystr(keyid));
	keyserver_import_fpr (ctrl,
	sig->revkey[idx].fpr,
	sig->revkey[idx].fprlen,
	opt.keyserver, 0);

	/* Do we have it now? */
	err = get_pubkey_byfpr_fast (ctrl, NULL,
	sig->revkey[idx].fpr,
	sig->revkey[idx].fprlen);
	}

	if (gpg_err_code (err) == GPG_ERR_NO_PUBKEY
	\|\| gpg_err_code (err) == GPG_ERR_UNUSABLE_PUBKEY)
	log_info(_("WARNING: key %s may be revoked:"
	" revocation key %s not present.\n"),
	tempkeystr,keystr(keyid));

	xfree(tempkeystr);
	}
	}
	}
	}
	}
	}
	}


	/*
	* compare and merge the blocks
	*
	* o compare the signatures: If we already have this signature, check
	* that they compare okay; if not, issue a warning and ask the user.
	* o Simply add the signature. Can't verify here because we may not have
	* the signature's public key yet; verification is done when putting it
	* into the trustdb, which is done automagically as soon as this pubkey
	* is used.
	* Note: We indicate newly inserted packets with NODE_FLAG_A.
	*/
	static int
	merge_blocks (ctrl_t ctrl, unsigned int options,
	kbnode_t keyblock_orig, kbnode_t keyblock,
	u32 keyid, u32 curtime, int origin, const char url,
	int n_uids, int n_sigs, int *n_subk )
	{
	kbnode_t onode, node;
	int rc, found;

	/* 1st: handle revocation certificates */
	for (node=keyblock->next; node; node=node->next )
	{
	if (node->pkt->pkttype == PKT_USER_ID )
	break;
	else if (node->pkt->pkttype == PKT_SIGNATURE
	&& IS_KEY_REV (node->pkt->pkt.signature))
	{
	/* check whether we already have this */
	found = 0;
	for (onode=keyblock_orig->next; onode; onode=onode->next)
	{
	if (onode->pkt->pkttype == PKT_USER_ID )
	break;
	else if (onode->pkt->pkttype == PKT_SIGNATURE
	&& IS_KEY_REV (onode->pkt->pkt.signature)
	&& !cmp_signatures(onode->pkt->pkt.signature,
	node->pkt->pkt.signature))
	{
	found = 1;
	break;
	}
	}
	if (!found)
	{
	kbnode_t n2 = clone_kbnode(node);
	insert_kbnode( keyblock_orig, n2, 0 );
	n2->flag \|= NODE_FLAG_A;
	++*n_sigs;
	if(!opt.quiet)
	{
	char *p = get_user_id_native (ctrl, keyid);
	log_info(_("key %s: \"%s\" revocation"
	" certificate added\n"), keystr(keyid),p);
	xfree(p);
	}
	}
	}
	}

	/* 2nd: merge in any direct key (0x1F) sigs */
	for(node=keyblock->next; node; node=node->next)
	{
	if (node->pkt->pkttype == PKT_USER_ID )
	break;
	else if (node->pkt->pkttype == PKT_SIGNATURE
	&& IS_KEY_SIG (node->pkt->pkt.signature))
	{
	/* check whether we already have this */
	found = 0;
	for (onode=keyblock_orig->next; onode; onode=onode->next)
	{
	if (onode->pkt->pkttype == PKT_USER_ID)
	break;
	else if (onode->pkt->pkttype == PKT_SIGNATURE
	&& IS_KEY_SIG (onode->pkt->pkt.signature)
	&& !cmp_signatures(onode->pkt->pkt.signature,
	node->pkt->pkt.signature))
	{
	found = 1;
	break;
	}
	}
	if (!found )
	{
	kbnode_t n2 = clone_kbnode(node);
	insert_kbnode( keyblock_orig, n2, 0 );
	n2->flag \|= NODE_FLAG_A;
	++*n_sigs;
	if(!opt.quiet)
	log_info( _("key %s: direct key signature added\n"),
	keystr(keyid));
	}
	}
	}

	/* 3rd: try to merge new certificates in */
	for (onode=keyblock_orig->next; onode; onode=onode->next)
	{
	if (!(onode->flag & NODE_FLAG_A) && onode->pkt->pkttype == PKT_USER_ID)
	{
	/* find the user id in the imported keyblock */
	for (node=keyblock->next; node; node=node->next)
	if (node->pkt->pkttype == PKT_USER_ID
	&& !cmp_user_ids( onode->pkt->pkt.user_id,
	node->pkt->pkt.user_id ) )
	break;
	if (node ) /* found: merge */
	{
	rc = merge_sigs (onode, node, n_sigs);
	if (rc )
	return rc;
	}
	}
	}

	/* 4th: add new user-ids */
	for (node=keyblock->next; node; node=node->next)
	{
	if (node->pkt->pkttype == PKT_USER_ID)
	{
	/* do we have this in the original keyblock */
	for (onode=keyblock_orig->next; onode; onode=onode->next )
	if (onode->pkt->pkttype == PKT_USER_ID
	&& !cmp_user_ids( onode->pkt->pkt.user_id,
	node->pkt->pkt.user_id ) )
	break;
	if (!onode ) /* this is a new user id: append */
	{
	rc = append_new_uid (options, keyblock_orig, node,
	curtime, origin, url, n_sigs);
	if (rc )
	return rc;
	++*n_uids;
	}
	}
	}

	/* 5th: add new subkeys */
	for (node=keyblock->next; node; node=node->next)
	{
	onode = NULL;
	if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
	{
	/* do we have this in the original keyblock? */
	for(onode=keyblock_orig->next; onode; onode=onode->next)
	if (onode->pkt->pkttype == PKT_PUBLIC_SUBKEY
	&& !cmp_public_keys( onode->pkt->pkt.public_key,
	node->pkt->pkt.public_key))
	break;
	if (!onode ) /* This is a new subkey: append. */
	{
	rc = append_key (keyblock_orig, node, n_sigs);
	if (rc)
	return rc;
	++*n_subk;
	}
	}
	else if (node->pkt->pkttype == PKT_SECRET_SUBKEY)
	{
	/* do we have this in the original keyblock? */
	for (onode=keyblock_orig->next; onode; onode=onode->next )
	if (onode->pkt->pkttype == PKT_SECRET_SUBKEY
	&& !cmp_public_keys (onode->pkt->pkt.public_key,
	node->pkt->pkt.public_key) )
	break;
	if (!onode ) /* This is a new subkey: append. */
	{
	rc = append_key (keyblock_orig, node, n_sigs);
	if (rc )
	return rc;
	++*n_subk;
	}
	}
	}

	/* 6th: merge subkey certificates */
	for (onode=keyblock_orig->next; onode; onode=onode->next)
	{
	if (!(onode->flag & NODE_FLAG_A)
	&& (onode->pkt->pkttype == PKT_PUBLIC_SUBKEY
	\|\| onode->pkt->pkttype == PKT_SECRET_SUBKEY))
	{
	/* find the subkey in the imported keyblock */
	for(node=keyblock->next; node; node=node->next)
	{
	if ((node->pkt->pkttype == PKT_PUBLIC_SUBKEY
	\|\| node->pkt->pkttype == PKT_SECRET_SUBKEY)
	&& !cmp_public_keys( onode->pkt->pkt.public_key,
	node->pkt->pkt.public_key ) )
	break;
	}
	if (node) /* Found: merge. */
	{
	rc = merge_keysigs( onode, node, n_sigs);
	if (rc )
	return rc;
	}
	}
	}

	return 0;
	}


	/* Helper function for merge_blocks.
	*
	* Append the new userid starting with NODE and all signatures to
	* KEYBLOCK. ORIGIN and URL conveys the usual key origin info. The
	* integer at N_SIGS is updated with the number of new signatures.
	*/
	static gpg_error_t
	append_new_uid (unsigned int options,
	kbnode_t keyblock, kbnode_t node, u32 curtime,
	int origin, const char url, int n_sigs)
	{
	gpg_error_t err;
	kbnode_t n;
	kbnode_t n_where = NULL;

	log_assert (node->pkt->pkttype == PKT_USER_ID);

	/* Find the right position for the new user id and its signatures. */
	for (n = keyblock; n; n_where = n, n = n->next)
	{
	if (n->pkt->pkttype == PKT_PUBLIC_SUBKEY
	\|\| n->pkt->pkttype == PKT_SECRET_SUBKEY )
	break;
	}
	if (!n)
	n_where = NULL;

	/* and append/insert */
	while (node)
	{
	/* we add a clone to the original keyblock, because this
	* one is released first. */
	n = clone_kbnode(node);
	if (n->pkt->pkttype == PKT_USER_ID
	&& !(options & IMPORT_RESTORE) )
	{
	err = insert_key_origin_uid (n->pkt->pkt.user_id,
	curtime, origin, url);
	if (err)
	{
	release_kbnode (n);
	return err;
	}
	}

	if (n_where)
	{
	insert_kbnode( n_where, n, 0 );
	n_where = n;
	}
	else
	add_kbnode( keyblock, n );
	n->flag \|= NODE_FLAG_A;
	node->flag \|= NODE_FLAG_A;
	if (n->pkt->pkttype == PKT_SIGNATURE )
	++*n_sigs;

	node = node->next;
	if (node && node->pkt->pkttype != PKT_SIGNATURE )
	break;
	}

	return 0;
	}


	/* Helper function for merge_blocks
	* Merge the sigs from SRC onto DST. SRC and DST are both a PKT_USER_ID.
	* (how should we handle comment packets here?)
	*/
	static int
	merge_sigs (kbnode_t dst, kbnode_t src, int *n_sigs)
	{
	kbnode_t n, n2;
	int found = 0;

	log_assert (dst->pkt->pkttype == PKT_USER_ID);
	log_assert (src->pkt->pkttype == PKT_USER_ID);

	for (n=src->next; n && n->pkt->pkttype != PKT_USER_ID; n = n->next)
	{
	if (n->pkt->pkttype != PKT_SIGNATURE )
	continue;
	if (IS_SUBKEY_SIG (n->pkt->pkt.signature)
	\|\| IS_SUBKEY_REV (n->pkt->pkt.signature) )
	continue; /* skip signatures which are only valid on subkeys */

	found = 0;
	for (n2=dst->next; n2 && n2->pkt->pkttype != PKT_USER_ID; n2 = n2->next)
	if (!cmp_signatures(n->pkt->pkt.signature,n2->pkt->pkt.signature))
	{
	found++;
	break;
	}
	if (!found )
	{
	/* This signature is new or newer, append N to DST.
	* We add a clone to the original keyblock, because this
	* one is released first */
	n2 = clone_kbnode(n);
	insert_kbnode( dst, n2, PKT_SIGNATURE );
	n2->flag \|= NODE_FLAG_A;
	n->flag \|= NODE_FLAG_A;
	++*n_sigs;
	}
	}

	return 0;
	}


	/* Helper function for merge_blocks
	* Merge the sigs from SRC onto DST. SRC and DST are both a PKT_xxx_SUBKEY.
	*/
	static int
	merge_keysigs (kbnode_t dst, kbnode_t src, int *n_sigs)
	{
	kbnode_t n, n2;
	int found = 0;

	log_assert (dst->pkt->pkttype == PKT_PUBLIC_SUBKEY
	\|\| dst->pkt->pkttype == PKT_SECRET_SUBKEY);

	for (n=src->next; n ; n = n->next)
	{
	if (n->pkt->pkttype == PKT_PUBLIC_SUBKEY
	\|\| n->pkt->pkttype == PKT_PUBLIC_KEY )
	break;
	if (n->pkt->pkttype != PKT_SIGNATURE )
	continue;

	found = 0;
	for (n2=dst->next; n2; n2 = n2->next)
	{
	if (n2->pkt->pkttype == PKT_PUBLIC_SUBKEY
	\|\| n2->pkt->pkttype == PKT_PUBLIC_KEY )
	break;
	if (n2->pkt->pkttype == PKT_SIGNATURE
	&& (n->pkt->pkt.signature->keyid[0]
	== n2->pkt->pkt.signature->keyid[0])
	&& (n->pkt->pkt.signature->keyid[1]
	== n2->pkt->pkt.signature->keyid[1])
	&& (n->pkt->pkt.signature->timestamp
	<= n2->pkt->pkt.signature->timestamp)
	&& (n->pkt->pkt.signature->sig_class
	== n2->pkt->pkt.signature->sig_class))
	{
	found++;
	break;
	}
	}
	if (!found )
	{
	/* This signature is new or newer, append N to DST.
	* We add a clone to the original keyblock, because this
	* one is released first */
	n2 = clone_kbnode(n);
	insert_kbnode( dst, n2, PKT_SIGNATURE );
	n2->flag \|= NODE_FLAG_A;
	n->flag \|= NODE_FLAG_A;
	++*n_sigs;
	}
	}

	return 0;
	}


	/* Helper function for merge_blocks.
	* Append the subkey starting with NODE and all signatures to KEYBLOCK.
	* Mark all new and copied packets by setting flag bit 0.
	*/
	static int
	append_key (kbnode_t keyblock, kbnode_t node, int *n_sigs)
	{
	kbnode_t n;

	log_assert (node->pkt->pkttype == PKT_PUBLIC_SUBKEY
	\|\| node->pkt->pkttype == PKT_SECRET_SUBKEY);

	while (node)
	{
	/* we add a clone to the original keyblock, because this
	* one is released first */
	n = clone_kbnode(node);
	add_kbnode( keyblock, n );
	n->flag \|= NODE_FLAG_A;
	node->flag \|= NODE_FLAG_A;
	if (n->pkt->pkttype == PKT_SIGNATURE )
	++*n_sigs;

	node = node->next;
	if (node && node->pkt->pkttype != PKT_SIGNATURE )
	break;
	}

	return 0;
	}
	diff --git a/g10/keydb.c b/g10/keydb.c
	index cdad8a450..208622b33 100644
	--- a/g10/keydb.c
	+++ b/g10/keydb.c
	@@ -1,2006 +1,2001 @@
	/* keydb.c - key database dispatcher
	* Copyright (C) 2001-2013 Free Software Foundation, Inc.
	* Copyright (C) 2001-2015 Werner Koch
	* Copyright (C) 2019,2024 g10 Code GmbH
	*
	* This file is part of GnuPG.
	*
	* GnuPG is free software; you can redistribute it and/or modify
	* it under the terms of the GNU General Public License as published by
	* the Free Software Foundation; either version 3 of the License, or
	* (at your option) any later version.
	*
	* GnuPG is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with this program; if not, see <https://www.gnu.org/licenses/>.
	* SPDX-License-Identifier: GPL-3.0-or-later
	*/

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

	#include "gpg.h"
	#include "../common/util.h"
	#include "../common/sysutils.h"
	#include "options.h"
	#include "main.h" /try_make_homedir ()/
	#include "packet.h"
	#include "keyring.h"
	#include "../kbx/keybox.h"
	#include "keydb.h"
	#include "../common/i18n.h"
	#include "../common/comopt.h"

	#include "keydb-private.h" /* For struct keydb_handle_s */

	static int active_handles;


	static struct resource_item all_resources[MAX_KEYDB_RESOURCES];
	static int used_resources;

	/* A pointer used to check for the primary key database by comparing
	to the struct resource_item's TOKEN. */
	static void *primary_keydb;

	/* Whether we have successfully registered any resource. */
	static int any_registered;

	/* Looking up keys is expensive. To hide the cost, we cache whether
	keys exist in the key database. Then, if we know a key does not
	exist, we don't have to spend time looking it up. This
	particularly helps the --list-sigs and --check-sigs commands.

	The cache stores the results in a hash using separate chaining.
	Concretely: we use the LSB of the keyid to index the hash table and
	each bucket consists of a linked list of entries. An entry
	consists of the 64-bit key id. If a key id is not in the cache,
	then we don't know whether it is in the DB or not.

	To simplify the cache consistency protocol, we simply flush the
	whole cache whenever a key is inserted or updated. */

	#define KID_NOT_FOUND_CACHE_BUCKETS 256
	static struct kid_not_found_cache_bucket *
	kid_not_found_cache[KID_NOT_FOUND_CACHE_BUCKETS];

	struct kid_not_found_cache_bucket
	{
	struct kid_not_found_cache_bucket *next;
	u32 kid[2];
	};

	struct
	{
	unsigned int count; /* The current number of entries in the hash table. */
	unsigned int peak; /* The peak of COUNT. */
	unsigned int flushes; /* The number of flushes. */
	} kid_not_found_stats;

	struct
	{
	unsigned int handles; /* Number of handles created. */
	unsigned int locks; /* Number of locks taken. */
	unsigned int parse_keyblocks; /* Number of parse_keyblock_image calls. */
	unsigned int get_keyblocks; /* Number of keydb_get_keyblock calls. */
	unsigned int build_keyblocks; /* Number of build_keyblock_image calls. */
	unsigned int update_keyblocks;/* Number of update_keyblock calls. */
	unsigned int insert_keyblocks;/* Number of update_keyblock calls. */
	unsigned int delete_keyblocks;/* Number of delete_keyblock calls. */
	unsigned int search_resets; /* Number of keydb_search_reset calls. */
	unsigned int found; /* Number of successful keydb_search calls. */
	unsigned int found_cached; /* Ditto but from the cache. */
	unsigned int notfound; /* Number of failed keydb_search calls. */
	unsigned int notfound_cached; /* Ditto but from the cache. */
	} keydb_stats;


	static int lock_all (KEYDB_HANDLE hd);
	static void unlock_all (KEYDB_HANDLE hd);


	/* Check whether the keyid KID is in key id is definitely not in the
	database.

	Returns:

	0 - Indeterminate: the key id is not in the cache; we don't know
	whether the key is in the database or not. If you want a
	definitive answer, you'll need to perform a lookup.

	1 - There is definitely no key with this key id in the database.
	We searched for a key with this key id previously, but we
	didn't find it in the database. */
	static int
	kid_not_found_p (u32 *kid)
	{
	struct kid_not_found_cache_bucket *k;

	for (k = kid_not_found_cache[kid[0] % KID_NOT_FOUND_CACHE_BUCKETS]; k; k = k->next)
	if (k->kid[0] == kid[0] && k->kid[1] == kid[1])
	{
	if (DBG_CACHE)
	log_debug ("keydb: kid_not_found_p (%08lx%08lx) => not in DB\n",
	(ulong)kid[0], (ulong)kid[1]);
	return 1;
	}

	if (DBG_CACHE)
	log_debug ("keydb: kid_not_found_p (%08lx%08lx) => indeterminate\n",
	(ulong)kid[0], (ulong)kid[1]);
	return 0;
	}


	/* Insert the keyid KID into the kid_not_found_cache. FOUND is whether
	the key is in the key database or not.

	Note this function does not check whether the key id is already in
	the cache. As such, kid_not_found_p() should be called first. */
	static void
	kid_not_found_insert (u32 *kid)
	{
	struct kid_not_found_cache_bucket *k;

	if (DBG_CACHE)
	log_debug ("keydb: kid_not_found_insert (%08lx%08lx)\n",
	(ulong)kid[0], (ulong)kid[1]);
	k = xmalloc (sizeof *k);
	k->kid[0] = kid[0];
	k->kid[1] = kid[1];
	k->next = kid_not_found_cache[kid[0] % KID_NOT_FOUND_CACHE_BUCKETS];
	kid_not_found_cache[kid[0] % KID_NOT_FOUND_CACHE_BUCKETS] = k;
	kid_not_found_stats.count++;
	}


	/* Flush the kid not found cache. */
	static void
	kid_not_found_flush (void)
	{
	struct kid_not_found_cache_bucket k, knext;
	int i;

	if (DBG_CACHE)
	log_debug ("keydb: kid_not_found_flush\n");

	if (!kid_not_found_stats.count)
	return;

	for (i=0; i < DIM(kid_not_found_cache); i++)
	{
	for (k = kid_not_found_cache[i]; k; k = knext)
	{
	knext = k->next;
	xfree (k);
	}
	kid_not_found_cache[i] = NULL;
	}
	if (kid_not_found_stats.count > kid_not_found_stats.peak)
	kid_not_found_stats.peak = kid_not_found_stats.count;
	kid_not_found_stats.count = 0;
	kid_not_found_stats.flushes++;
	}


	static void
	keyblock_cache_clear (struct keydb_handle_s *hd)
	{
	hd->keyblock_cache.state = KEYBLOCK_CACHE_EMPTY;
	iobuf_close (hd->keyblock_cache.iobuf);
	hd->keyblock_cache.iobuf = NULL;
	hd->keyblock_cache.resource = -1;
	hd->keyblock_cache.offset = -1;
	}


	/* Handle the creation of a keyring or a keybox if it does not yet
	exist. Take into account that other processes might have the
	keyring/keybox already locked. This lock check does not work if
	the directory itself is not yet available. If IS_BOX is true the
	filename is expected to refer to a keybox. If FORCE_CREATE is true
	the keyring or keybox will be created.

	Return 0 if it is okay to access the specified file. */
	static gpg_error_t
	maybe_create_keyring_or_box (char *filename, int is_box, int force_create)
	{
	gpg_err_code_t ec;
	dotlock_t lockhd = NULL;
	IOBUF iobuf;
	int rc;
	mode_t oldmask;
	char *last_slash_in_filename;
	char *bak_fname = NULL;
	char *tmp_fname = NULL;
	int save_slash;

	/* A quick test whether the filename already exists. */
	if (!gnupg_access (filename, F_OK))
	return !gnupg_access (filename, R_OK)? 0 : gpg_error (GPG_ERR_EACCES);

	/* If we don't want to create a new file at all, there is no need to
	go any further - bail out right here. */
	if (!force_create)
	return gpg_error (GPG_ERR_ENOENT);

	/* First of all we try to create the home directory. Note, that we
	don't do any locking here because any sane application of gpg
	would create the home directory by itself and not rely on gpg's
	tricky auto-creation which is anyway only done for certain home
	directory name pattern. */
	last_slash_in_filename = strrchr (filename, DIRSEP_C);
	#if HAVE_W32_SYSTEM
	{
	/* Windows may either have a slash or a backslash. Take care of it. */
	char *p = strrchr (filename, '/');
	if (!last_slash_in_filename \|\| p > last_slash_in_filename)
	last_slash_in_filename = p;
	}
	#endif /HAVE_W32_SYSTEM/
	if (!last_slash_in_filename)
	return gpg_error (GPG_ERR_ENOENT); /* No slash at all - should
	not happen though. */
	save_slash = *last_slash_in_filename;
	*last_slash_in_filename = 0;
	if (gnupg_access(filename, F_OK))
	{
	static int tried;

	if (!tried)
	{
	tried = 1;
	try_make_homedir (filename);
	}
	if ((ec = gnupg_access (filename, F_OK)))
	{
	rc = gpg_error (ec);
	*last_slash_in_filename = save_slash;
	goto leave;
	}

	*last_slash_in_filename = save_slash;

	if (!opt.use_keyboxd
	&& !parse_comopt (GNUPG_MODULE_NAME_GPG, 0)
	&& comopt.use_keyboxd)
	{
	/* The above try_make_homedir created a new default hoemdir
	* and also wrote a new common.conf. Thus we now see that
	* use-keyboxd has been set. Let's set this option and
	* return a dedicated error code. */
	opt.use_keyboxd = comopt.use_keyboxd;
	rc = gpg_error (GPG_ERR_TRUE);
	goto leave;
	}
	}
	else
	*last_slash_in_filename = save_slash;

	/* To avoid races with other instances of gpg trying to create or
	update the keyring (it is removed during an update for a short
	time), we do the next stuff in a locked state. */
	lockhd = dotlock_create (filename, 0);
	if (!lockhd)
	{
	rc = gpg_error_from_syserror ();
	/* A reason for this to fail is that the directory is not
	writable. However, this whole locking stuff does not make
	sense if this is the case. An empty non-writable directory
	with no keyring is not really useful at all. */
	if (opt.verbose)
	log_info ("can't allocate lock for '%s': %s\n",
	filename, gpg_strerror (rc));

	if (!force_create)
	return gpg_error (GPG_ERR_ENOENT); /* Won't happen. */
	else
	return rc;
	}

	if ( dotlock_take (lockhd, -1) )
	{
	rc = gpg_error_from_syserror ();
	/* This is something bad. Probably a stale lockfile. */
	log_info ("can't lock '%s': %s\n", filename, gpg_strerror (rc));
	goto leave;
	}

	/* Now the real test while we are locked. */

	/* Gpg either uses pubring.gpg or pubring.kbx and thus different
	* lock files. Now, when one gpg process is updating a pubring.gpg
	* and thus holding the corresponding lock, a second gpg process may
	* get to here at the time between the two rename operation used by
	* the first process to update pubring.gpg. The lock taken above
	* may not protect the second process if it tries to create a
	* pubring.kbx file which would be protected by a different lock
	* file.
	*
	* We can detect this case by checking that the two temporary files
	* used by the update code exist at the same time. In that case we
	* do not create a new file but act as if FORCE_CREATE has not been
	* given. Obviously there is a race between our two checks but the
	* worst thing is that we won't create a new file, which is better
	* than to accidentally creating one. */
	rc = keybox_tmp_names (filename, is_box, &bak_fname, &tmp_fname);
	if (rc)
	goto leave;

	if (!gnupg_access (filename, F_OK))
	{
	rc = 0; /* Okay, we may access the file now. */
	goto leave;
	}
	if (!gnupg_access (bak_fname, F_OK) && !gnupg_access (tmp_fname, F_OK))
	{
	/* Very likely another process is updating a pubring.gpg and we
	should not create a pubring.kbx. */
	rc = gpg_error (GPG_ERR_ENOENT);
	goto leave;
	}


	/* The file does not yet exist, create it now. */
	oldmask = umask (077);
	if (is_secured_filename (filename))
	{
	iobuf = NULL;
	gpg_err_set_errno (EPERM);
	}
	else
	iobuf = iobuf_create (filename, 0);
	umask (oldmask);
	if (!iobuf)
	{
	rc = gpg_error_from_syserror ();
	if (is_box)
	log_error (_("error creating keybox '%s': %s\n"),
	filename, gpg_strerror (rc));
	else
	log_error (_("error creating keyring '%s': %s\n"),
	filename, gpg_strerror (rc));
	goto leave;
	}

	iobuf_close (iobuf);
	/* Must invalidate that ugly cache */
	iobuf_ioctl (NULL, IOBUF_IOCTL_INVALIDATE_CACHE, 0, filename);

	/* Make sure that at least one record is in a new keybox file, so
	that the detection magic will work the next time it is used. */
	if (is_box)
	{
	estream_t fp = es_fopen (filename, "wb");
	if (!fp)
	rc = gpg_error_from_syserror ();
	else
	{
	rc = _keybox_write_header_blob (fp, 1);
	es_fclose (fp);
	}
	if (rc)
	{
	if (is_box)
	log_error (_("error creating keybox '%s': %s\n"),
	filename, gpg_strerror (rc));
	else
	log_error (_("error creating keyring '%s': %s\n"),
	filename, gpg_strerror (rc));
	goto leave;
	}
	}

	if (!opt.quiet)
	{
	if (is_box)
	log_info (_("keybox '%s' created\n"), filename);
	else
	log_info (_("keyring '%s' created\n"), filename);
	}

	rc = 0;

	leave:
	if (lockhd)
	{
	dotlock_release (lockhd);
	dotlock_destroy (lockhd);
	}
	xfree (bak_fname);
	xfree (tmp_fname);
	return rc;
	}


	/* Helper for keydb_add_resource. Opens FILENAME to figure out the
	resource type.

	Returns the specified file's likely type. If the file does not
	exist, returns KEYDB_RESOURCE_TYPE_NONE and sets *R_FOUND to 0.
	Otherwise, tries to figure out the file's type. This is either
	KEYDB_RESOURCE_TYPE_KEYBOX, KEYDB_RESOURCE_TYPE_KEYRING or
	KEYDB_RESOURCE_TYPE_KEYNONE. If the file is a keybox and it has
	the OpenPGP flag set, then R_OPENPGP is also set. */
	static KeydbResourceType
	rt_from_file (const char filename, int r_found, int *r_openpgp)
	{
	u32 magic;
	unsigned char verbuf[4];
	estream_t fp;
	KeydbResourceType rt = KEYDB_RESOURCE_TYPE_NONE;

	r_found = r_openpgp = 0;
	fp = es_fopen (filename, "rb");
	if (fp)
	{
	*r_found = 1;

	if (es_fread (&magic, 4, 1, fp) == 1 )
	{
	if (magic == 0x13579ace \|\| magic == 0xce9a5713)
	; /* GDBM magic - not anymore supported. */
	else if (es_fread (&verbuf, 4, 1, fp) == 1
	&& verbuf[0] == 1
	&& es_fread (&magic, 4, 1, fp) == 1
	&& !memcmp (&magic, "KBXf", 4))
	{
	if ((verbuf[3] & 0x02))
	*r_openpgp = 1;
	rt = KEYDB_RESOURCE_TYPE_KEYBOX;
	}
	else
	rt = KEYDB_RESOURCE_TYPE_KEYRING;
	}
	else /* Maybe empty: assume keyring. */
	rt = KEYDB_RESOURCE_TYPE_KEYRING;

	es_fclose (fp);
	}

	return rt;
	}

	char *
	keydb_search_desc_dump (struct keydb_search_desc *desc)
	{
	char b[MAX_FORMATTED_FINGERPRINT_LEN + 1];
	char fpr[2 * MAX_FINGERPRINT_LEN + 1];

	#if MAX_FINGERPRINT_LEN < UBID_LEN \|\| MAX_FINGERPRINT_LEN < KEYGRIP_LEN
	#error MAX_FINGERPRINT_LEN is shorter than KEYGRIP or UBID length.
	#endif

	switch (desc->mode)
	{
	case KEYDB_SEARCH_MODE_EXACT:
	return xasprintf ("EXACT: '%s'", desc->u.name);
	case KEYDB_SEARCH_MODE_SUBSTR:
	return xasprintf ("SUBSTR: '%s'", desc->u.name);
	case KEYDB_SEARCH_MODE_MAIL:
	return xasprintf ("MAIL: '%s'", desc->u.name);
	case KEYDB_SEARCH_MODE_MAILSUB:
	return xasprintf ("MAILSUB: '%s'", desc->u.name);
	case KEYDB_SEARCH_MODE_MAILEND:
	return xasprintf ("MAILEND: '%s'", desc->u.name);
	case KEYDB_SEARCH_MODE_WORDS:
	return xasprintf ("WORDS: '%s'", desc->u.name);
	case KEYDB_SEARCH_MODE_SHORT_KID:
	return xasprintf ("SHORT_KID: '%s'",
	format_keyid (desc->u.kid, KF_SHORT, b, sizeof (b)));
	case KEYDB_SEARCH_MODE_LONG_KID:
	return xasprintf ("LONG_KID: '%s'",
	format_keyid (desc->u.kid, KF_LONG, b, sizeof (b)));
	case KEYDB_SEARCH_MODE_FPR:
	bin2hex (desc->u.fpr, desc->fprlen, fpr);
	return xasprintf ("FPR%02d: '%s'", desc->fprlen,
	format_hexfingerprint (fpr, b, sizeof (b)));
	case KEYDB_SEARCH_MODE_ISSUER:
	return xasprintf ("ISSUER: '%s'", desc->u.name);
	case KEYDB_SEARCH_MODE_ISSUER_SN:
	return xasprintf ("ISSUER_SN: '#%.*s/%s'",
	(int)desc->snlen,desc->sn, desc->u.name);
	case KEYDB_SEARCH_MODE_SN:
	return xasprintf ("SN: '%.*s'",
	(int)desc->snlen, desc->sn);
	case KEYDB_SEARCH_MODE_SUBJECT:
	return xasprintf ("SUBJECT: '%s'", desc->u.name);
	case KEYDB_SEARCH_MODE_KEYGRIP:
	bin2hex (desc[0].u.grip, KEYGRIP_LEN, fpr);
	return xasprintf ("KEYGRIP: %s", fpr);
	case KEYDB_SEARCH_MODE_UBID:
	bin2hex (desc[0].u.ubid, UBID_LEN, fpr);
	return xasprintf ("UBID: %s", fpr);
	case KEYDB_SEARCH_MODE_FIRST:
	return xasprintf ("FIRST");
	case KEYDB_SEARCH_MODE_NEXT:
	return xasprintf ("NEXT");
	default:
	return xasprintf ("Bad search mode (%d)", desc->mode);
	}
	}



	/* Register a resource (keyring or keybox). The first keyring or
	* keybox that is added using this function is created if it does not
	* already exist and the KEYDB_RESOURCE_FLAG_READONLY is not set.
	*
	* FLAGS are a combination of the KEYDB_RESOURCE_FLAG_* constants.
	*
	* URL must have the following form:
	*
	* gnupg-ring:filename = plain keyring
	* gnupg-kbx:filename = keybox file
	* filename = check file's type (create as a plain keyring)
	*
	* Note: on systems with drive letters (Windows) invalid URLs (i.e.,
	* those with an unrecognized part before the ':' such as "c:\...")
	* will silently be treated as bare filenames. On other systems, such
	* URLs will cause this function to return GPG_ERR_GENERAL.
	*
	* If KEYDB_RESOURCE_FLAG_DEFAULT is set, the resource is a keyring
	* and the file ends in ".gpg", then this function also checks if a
	* file with the same name, but the extension ".kbx" exists, is a
	* keybox and the OpenPGP flag is set. If so, this function opens
	* that resource instead.
	*
	* If the file is not found, KEYDB_RESOURCE_FLAG_GPGVDEF is set and
	* the URL ends in ".kbx", then this function will try opening the
	* same URL, but with the extension ".gpg". If that file is a keybox
	* with the OpenPGP flag set or it is a keyring, then we use that
	* instead.
	*
	* If the file is not found, KEYDB_RESOURCE_FLAG_DEFAULT is set, the
	* file should be created and the file's extension is ".gpg" then we
	* replace the extension with ".kbx".
	*
	* If the KEYDB_RESOURCE_FLAG_PRIMARY is set and the resource is a
	* keyring (not a keybox), then this resource is considered the
	* primary resource. This is used by keydb_locate_writable(). If
	* another primary keyring is set, then that keyring is considered the
	* primary.
	*
	* If KEYDB_RESOURCE_FLAG_READONLY is set and the resource is a
	* keyring (not a keybox), then the keyring is marked as read only and
	* operations just as keyring_insert_keyblock will return
	* GPG_ERR_ACCESS.
	*/
	gpg_error_t
	keydb_add_resource (const char *url, unsigned int flags)
	{
	/* The file named by the URL (i.e., without the prototype). */
	const char *resname = url;

	char *filename = NULL;
	int create;
	int read_only = !!(flags&KEYDB_RESOURCE_FLAG_READONLY);
	int is_default = !!(flags&KEYDB_RESOURCE_FLAG_DEFAULT);
	int is_gpgvdef = !!(flags&KEYDB_RESOURCE_FLAG_GPGVDEF);
	gpg_error_t err = 0;
	KeydbResourceType rt = KEYDB_RESOURCE_TYPE_NONE;
	void *token;

	/* Create the resource if it is the first registered one. */
	create = (!read_only && !any_registered);

	if (strlen (resname) > 11 && !strncmp( resname, "gnupg-ring:", 11) )
	{
	rt = KEYDB_RESOURCE_TYPE_KEYRING;
	resname += 11;
	}
	else if (strlen (resname) > 10 && !strncmp (resname, "gnupg-kbx:", 10) )
	{
	rt = KEYDB_RESOURCE_TYPE_KEYBOX;
	resname += 10;
	}
	#if !defined(HAVE_DRIVE_LETTERS) && !defined(__riscos__)
	else if (strchr (resname, ':'))
	{
	log_error ("invalid key resource URL '%s'\n", url );
	err = gpg_error (GPG_ERR_GENERAL);
	goto leave;
	}
	#endif /* !HAVE_DRIVE_LETTERS && !__riscos__ */

	if (*resname != DIRSEP_C
	#ifdef HAVE_W32_SYSTEM
	&& resname != '/' / Fixme: does not handle drive letters. */
	#endif
	)
	{
	/* Do tilde expansion etc. */
	if (strchr (resname, DIRSEP_C)
	#ifdef HAVE_W32_SYSTEM
	\|\| strchr (resname, '/') /* Windows also accepts this. */
	#endif
	)
	filename = make_filename (resname, NULL);
	else
	filename = make_filename (gnupg_homedir (), resname, NULL);
	}
	else
	filename = xstrdup (resname);

	/* See whether we can determine the filetype. */
	if (rt == KEYDB_RESOURCE_TYPE_NONE)
	{
	int found, openpgp_flag;
	int pass = 0;
	size_t filenamelen;

	check_again:
	filenamelen = strlen (filename);
	rt = rt_from_file (filename, &found, &openpgp_flag);
	if (found)
	{
	/* The file exists and we have the resource type in RT.

	Now let us check whether in addition to the "pubring.gpg"
	a "pubring.kbx with openpgp keys exists. This is so that
	GPG 2.1 will use an existing "pubring.kbx" by default iff
	that file has been created or used by 2.1. This check is
	needed because after creation or use of the kbx file with
	2.1 an older version of gpg may have created a new
	pubring.gpg for its own use. */
	if (!pass && is_default && rt == KEYDB_RESOURCE_TYPE_KEYRING
	&& filenamelen > 4 && !strcmp (filename+filenamelen-4, ".gpg"))
	{
	strcpy (filename+filenamelen-4, ".kbx");
	if ((rt_from_file (filename, &found, &openpgp_flag)
	== KEYDB_RESOURCE_TYPE_KEYBOX) && found && openpgp_flag)
	rt = KEYDB_RESOURCE_TYPE_KEYBOX;
	else /* Restore filename */
	strcpy (filename+filenamelen-4, ".gpg");
	}
	}
	else if (!pass && is_gpgvdef
	&& filenamelen > 4 && !strcmp (filename+filenamelen-4, ".kbx"))
	{
	/* Not found but gpgv's default "trustedkeys.kbx" file has
	been requested. We did not found it so now check whether
	a "trustedkeys.gpg" file exists and use that instead. */
	KeydbResourceType rttmp;

	strcpy (filename+filenamelen-4, ".gpg");
	rttmp = rt_from_file (filename, &found, &openpgp_flag);
	if (found
	&& ((rttmp == KEYDB_RESOURCE_TYPE_KEYBOX && openpgp_flag)
	\|\| (rttmp == KEYDB_RESOURCE_TYPE_KEYRING)))
	rt = rttmp;
	else /* Restore filename */
	strcpy (filename+filenamelen-4, ".kbx");
	}
	else if (!pass
	&& is_default && create
	&& filenamelen > 4 && !strcmp (filename+filenamelen-4, ".gpg"))
	{
	/* The file does not exist, the default resource has been
	requested, the file shall be created, and the file has a
	".gpg" suffix. Change the suffix to ".kbx" and try once
	more. This way we achieve that we open an existing
	".gpg" keyring, but create a new keybox file with an
	".kbx" suffix. */
	strcpy (filename+filenamelen-4, ".kbx");
	pass++;
	goto check_again;
	}
	else /* No file yet: create keybox. */
	rt = KEYDB_RESOURCE_TYPE_KEYBOX;
	}

	switch (rt)
	{
	case KEYDB_RESOURCE_TYPE_NONE:
	log_error ("unknown type of key resource '%s'\n", url );
	err = gpg_error (GPG_ERR_GENERAL);
	goto leave;

	case KEYDB_RESOURCE_TYPE_KEYRING:
	err = maybe_create_keyring_or_box (filename, 0, create);
	if (err)
	goto leave;

	if (keyring_register_filename (filename, read_only, &token))
	{
	if (used_resources >= MAX_KEYDB_RESOURCES)
	err = gpg_error (GPG_ERR_RESOURCE_LIMIT);
	else
	{
	if ((flags & KEYDB_RESOURCE_FLAG_PRIMARY))
	primary_keydb = token;
	all_resources[used_resources].type = rt;
	all_resources[used_resources].u.kr = NULL; /* Not used here */
	all_resources[used_resources].token = token;
	used_resources++;
	}
	}
	else
	{
	/* This keyring was already registered, so ignore it.
	However, we can still mark it as primary even if it was
	already registered. */
	if ((flags & KEYDB_RESOURCE_FLAG_PRIMARY))
	primary_keydb = token;
	}
	break;

	case KEYDB_RESOURCE_TYPE_KEYBOX:
	{
	err = maybe_create_keyring_or_box (filename, 1, create);
	if (err)
	goto leave;

	err = keybox_register_file (filename, 0, &token);
	if (!err)
	{
	if (used_resources >= MAX_KEYDB_RESOURCES)
	err = gpg_error (GPG_ERR_RESOURCE_LIMIT);
	else
	{
	if ((flags & KEYDB_RESOURCE_FLAG_PRIMARY))
	primary_keydb = token;
	all_resources[used_resources].type = rt;
	all_resources[used_resources].u.kb = NULL; /* Not used here */
	all_resources[used_resources].token = token;

	if (!(flags & KEYDB_RESOURCE_FLAG_READONLY))
	/* Do a compress run if needed and no other user is
	* currently using the keybox. */
	keybox_compress_when_no_other_users (token, 1);
	used_resources++;
	}
	}
	else if (gpg_err_code (err) == GPG_ERR_EEXIST)
	{
	/* Already registered. We will mark it as the primary key
	if requested. */
	if ((flags & KEYDB_RESOURCE_FLAG_PRIMARY))
	primary_keydb = token;
	}
	}
	break;

	default:
	log_error ("resource type of '%s' not supported\n", url);
	err = gpg_error (GPG_ERR_GENERAL);
	goto leave;
	}

	/* fixme: check directory permissions and print a warning */

	leave:
	if (err)
	{
	if (gpg_err_code (err) != GPG_ERR_TRUE)
	{
	log_error (_("keyblock resource '%s': %s\n"),
	filename, gpg_strerror (err));
	write_status_error ("add_keyblock_resource", err);
	}
	}
	else
	any_registered = 1;
	xfree (filename);
	return err;
	}


	void
	keydb_dump_stats (void)
	{
	log_info ("keydb: handles=%u locks=%u parse=%u get=%u\n",
	keydb_stats.handles,
	keydb_stats.locks,
	keydb_stats.parse_keyblocks,
	keydb_stats.get_keyblocks);
	log_info (" build=%u update=%u insert=%u delete=%u\n",
	keydb_stats.build_keyblocks,
	keydb_stats.update_keyblocks,
	keydb_stats.insert_keyblocks,
	keydb_stats.delete_keyblocks);
	log_info (" reset=%u found=%u not=%u cache=%u not=%u\n",
	keydb_stats.search_resets,
	keydb_stats.found,
	keydb_stats.notfound,
	keydb_stats.found_cached,
	keydb_stats.notfound_cached);
	log_info ("kid_not_found_cache: count=%u peak=%u flushes=%u\n",
	kid_not_found_stats.count,
	kid_not_found_stats.peak,
	kid_not_found_stats.flushes);
	}


	/* keydb_new diverts to here in non-keyboxd mode. HD is just the
	* calloced structure with the handle type initialized. */
	gpg_error_t
	internal_keydb_init (KEYDB_HANDLE hd)
	{
	gpg_error_t err = 0;
	int i, j;
	int die = 0;
	int reterrno;

	log_assert (!hd->use_keyboxd);
	hd->found = -1;
	hd->saved_found = -1;
	hd->is_reset = 1;

	log_assert (used_resources <= MAX_KEYDB_RESOURCES);
	for (i=j=0; ! die && i < used_resources; i++)
	{
	switch (all_resources[i].type)
	{
	case KEYDB_RESOURCE_TYPE_NONE: /* ignore */
	break;
	case KEYDB_RESOURCE_TYPE_KEYRING:
	hd->active[j].type = all_resources[i].type;
	hd->active[j].token = all_resources[i].token;
	hd->active[j].u.kr = keyring_new (all_resources[i].token);
	if (!hd->active[j].u.kr)
	{
	reterrno = errno;
	die = 1;
	}
	j++;
	break;
	case KEYDB_RESOURCE_TYPE_KEYBOX:
	hd->active[j].type = all_resources[i].type;
	hd->active[j].token = all_resources[i].token;
	hd->active[j].u.kb = keybox_new_openpgp (all_resources[i].token, 0);
	if (!hd->active[j].u.kb)
	{
	reterrno = errno;
	die = 1;
	}
	j++;
	break;
	}
	}
	hd->used = j;

	active_handles++;
	keydb_stats.handles++;

	if (die)
	err = gpg_error_from_errno (reterrno);

	return err;
	}


	/* Free all non-keyboxd resources owned by the database handle.
	* keydb_release diverts to here. */
	void
	internal_keydb_deinit (KEYDB_HANDLE hd)
	{
	int i;

	log_assert (!hd->use_keyboxd);

	log_assert (active_handles > 0);
	active_handles--;

	hd->keep_lock = 0;
	unlock_all (hd);
	for (i=0; i < hd->used; i++)
	{
	switch (hd->active[i].type)
	{
	case KEYDB_RESOURCE_TYPE_NONE:
	break;
	case KEYDB_RESOURCE_TYPE_KEYRING:
	keyring_release (hd->active[i].u.kr);
	break;
	case KEYDB_RESOURCE_TYPE_KEYBOX:
	keybox_release (hd->active[i].u.kb);
	break;
	}
	}

	keyblock_cache_clear (hd);
	}


	/* Take a lock on the files immediately and not only during insert or
	* update. This lock is released with keydb_release. */
	static gpg_error_t
	internal_keydb_lock (KEYDB_HANDLE hd)
	{
	gpg_error_t err;

	log_assert (!hd->use_keyboxd);

	err = lock_all (hd);
	if (!err)
	hd->keep_lock = 1;

	return err;
	}


	/* Take a lock if we are not using the keyboxd. */
	gpg_error_t
	keydb_lock (KEYDB_HANDLE hd)
	{
	if (!hd)
	return gpg_error (GPG_ERR_INV_ARG);

	if (!hd->use_keyboxd)
	return internal_keydb_lock (hd);

	return 0;
	}


	/* Set a flag on the handle to suppress use of cached results. This
	* is required for updating a keyring and for key listings. Fixme:
	* Using a new parameter for keydb_new might be a better solution. */
	void
	keydb_disable_caching (KEYDB_HANDLE hd)
	{
	if (hd && !hd->use_keyboxd)
	hd->no_caching = 1;
	}


	/* Return the file name of the resource in which the current search
	* result was found or, if there is no search result, the filename of
	* the current resource (i.e., the resource that the file position
	* points to). Note: the filename is not necessarily the URL used to
	* open it!
	*
	* This function only returns NULL if no handle is specified, in all
	* other error cases an empty string is returned. */
	const char *
	keydb_get_resource_name (KEYDB_HANDLE hd)
	{
	int idx;
	const char *s = NULL;

	if (!hd)
	return NULL;

	if (hd->use_keyboxd)
	return "[keyboxd]";

	if ( hd->found >= 0 && hd->found < hd->used)
	idx = hd->found;
	else if ( hd->current >= 0 && hd->current < hd->used)
	idx = hd->current;
	else
	idx = 0;

	switch (hd->active[idx].type)
	{
	case KEYDB_RESOURCE_TYPE_NONE:
	s = NULL;
	break;
	case KEYDB_RESOURCE_TYPE_KEYRING:
	s = keyring_get_resource_name (hd->active[idx].u.kr);
	break;
	case KEYDB_RESOURCE_TYPE_KEYBOX:
	s = keybox_get_resource_name (hd->active[idx].u.kb);
	break;
	}

	return s? s: "";
	}



	static int
	lock_all (KEYDB_HANDLE hd)
	{
	int i, rc = 0;

	/* Fixme: This locking scheme may lead to a deadlock if the resources
	are not added in the same order by all processes. We are
	currently only allowing one resource so it is not a problem.
	[Oops: Who claimed the latter]

	To fix this we need to use a lock file to protect lock_all. */

	if (hd->keep_lock)
	return 0;

	for (i=0; !rc && i < hd->used; i++)
	{
	switch (hd->active[i].type)
	{
	case KEYDB_RESOURCE_TYPE_NONE:
	break;
	case KEYDB_RESOURCE_TYPE_KEYRING:
	rc = keyring_lock (hd->active[i].u.kr, 1);
	break;
	case KEYDB_RESOURCE_TYPE_KEYBOX:
	rc = keybox_lock (hd->active[i].u.kb, 1, -1);
	break;
	}
	}

	if (rc)
	{
	/* Revert the already taken locks. */
	for (i--; i >= 0; i--)
	{
	switch (hd->active[i].type)
	{
	case KEYDB_RESOURCE_TYPE_NONE:
	break;
	case KEYDB_RESOURCE_TYPE_KEYRING:
	keyring_lock (hd->active[i].u.kr, 0);
	break;
	case KEYDB_RESOURCE_TYPE_KEYBOX:
	keybox_lock (hd->active[i].u.kb, 0, 0);
	break;
	}
	}
	}
	else
	{
	hd->locked = 1;
	keydb_stats.locks++;
	}

	return rc;
	}


	static void
	do_fp_close (KEYDB_HANDLE hd)
	{
	int i;

	for (i=0; i < hd->used; i++)
	{
	switch (hd->active[i].type)
	{
	case KEYDB_RESOURCE_TYPE_NONE:
	break;
	case KEYDB_RESOURCE_TYPE_KEYRING:
	keyring_fp_close (hd->active[i].u.kr);
	break;
	case KEYDB_RESOURCE_TYPE_KEYBOX:
	keybox_fp_close (hd->active[i].u.kb);
	break;
	}
	}
	}

	static void
	unlock_all (KEYDB_HANDLE hd)
	{
	int i;

	do_fp_close (hd);

	if (!hd->locked)
	return;

	for (i=hd->used-1; i >= 0; i--)
	{
	switch (hd->active[i].type)
	{
	case KEYDB_RESOURCE_TYPE_NONE:
	break;
	case KEYDB_RESOURCE_TYPE_KEYRING:
	keyring_lock (hd->active[i].u.kr, 0);
	break;
	case KEYDB_RESOURCE_TYPE_KEYBOX:
	keybox_lock (hd->active[i].u.kb, 0, 0);
	break;
	}
	}
	hd->locked = 0;
	}



	/* Save the last found state and invalidate the current selection
	* (i.e., the entry selected by keydb_search() is invalidated and
	* something like keydb_get_keyblock() will return an error). This
	* does not change the file position. This makes it possible to do
	* something like:
	*
	* keydb_search (hd, ...); // Result 1.
	* keydb_push_found_state (hd);
	* keydb_search_reset (hd);
	* keydb_search (hd, ...); // Result 2.
	* keydb_pop_found_state (hd);
	* keydb_get_keyblock (hd, ...); // -> Result 1.
	*
	* Note: it is only possible to save a single save state at a time.
	* In other words, the save stack only has room for a single
	* instance of the state. */
	/* FIXME(keyboxd): This function is used only at one place - see how
	* we can avoid it. */
	void
	keydb_push_found_state (KEYDB_HANDLE hd)
	{
	if (!hd)
	return;

	if (hd->found < 0 \|\| hd->found >= hd->used)
	{
	hd->saved_found = -1;
	return;
	}

	switch (hd->active[hd->found].type)
	{
	case KEYDB_RESOURCE_TYPE_NONE:
	break;
	case KEYDB_RESOURCE_TYPE_KEYRING:
	keyring_push_found_state (hd->active[hd->found].u.kr);
	break;
	case KEYDB_RESOURCE_TYPE_KEYBOX:
	keybox_push_found_state (hd->active[hd->found].u.kb);
	break;
	}

	hd->saved_found = hd->found;
	hd->found = -1;
	}


	/* Restore the previous save state. If the saved state is NULL or
	invalid, this is a NOP. */
	/* FIXME(keyboxd): This function is used only at one place - see how
	* we can avoid it. */
	void
	keydb_pop_found_state (KEYDB_HANDLE hd)
	{
	if (!hd)
	return;

	hd->found = hd->saved_found;
	hd->saved_found = -1;
	if (hd->found < 0 \|\| hd->found >= hd->used)
	return;

	switch (hd->active[hd->found].type)
	{
	case KEYDB_RESOURCE_TYPE_NONE:
	break;
	case KEYDB_RESOURCE_TYPE_KEYRING:
	keyring_pop_found_state (hd->active[hd->found].u.kr);
	break;
	case KEYDB_RESOURCE_TYPE_KEYBOX:
	keybox_pop_found_state (hd->active[hd->found].u.kb);
	break;
	}
	}



	/* Parse the keyblock in IOBUF and return at R_KEYBLOCK. */
	gpg_error_t
	keydb_parse_keyblock (iobuf_t iobuf, int pk_no, int uid_no,
	kbnode_t *r_keyblock)
	{
	gpg_error_t err;
	struct parse_packet_ctx_s parsectx;
	PACKET *pkt;
	kbnode_t keyblock = NULL;
	kbnode_t node, *tail;
	int in_cert, save_mode;
	int pk_count, uid_count;

	*r_keyblock = NULL;

	pkt = xtrymalloc (sizeof *pkt);
	if (!pkt)
	return gpg_error_from_syserror ();
	init_packet (pkt);
	init_parse_packet (&parsectx, iobuf);
	save_mode = set_packet_list_mode (0);
	in_cert = 0;
	tail = NULL;
	pk_count = uid_count = 0;
	while ((err = parse_packet (&parsectx, pkt)) != -1)
	{
	if (gpg_err_code (err) == GPG_ERR_UNKNOWN_PACKET)
	{
	free_packet (pkt, &parsectx);
	init_packet (pkt);
	continue;
	}
	if (err)
	{
	es_fflush (es_stdout);
	log_error ("parse_keyblock_image: read error: %s\n",
	gpg_strerror (err));
	if (gpg_err_code (err) == GPG_ERR_INV_PACKET)
	{
	free_packet (pkt, &parsectx);
	init_packet (pkt);
	continue;
	}
	err = gpg_error (GPG_ERR_INV_KEYRING);
	break;
	}

	/* Filter allowed packets. */
	switch (pkt->pkttype)
	{
	case PKT_PUBLIC_KEY:
	case PKT_PUBLIC_SUBKEY:
	case PKT_SECRET_KEY:
	case PKT_SECRET_SUBKEY:
	case PKT_USER_ID:
	case PKT_ATTRIBUTE:
	case PKT_SIGNATURE:
	case PKT_RING_TRUST:
	break; /* Allowed per RFC. */

	default:
	log_info ("skipped packet of type %d in keybox\n", (int)pkt->pkttype);
	free_packet(pkt, &parsectx);
	init_packet(pkt);
	continue;
	}

	/* Other sanity checks. */
	if (!in_cert && pkt->pkttype != PKT_PUBLIC_KEY)
	{
	log_error ("parse_keyblock_image: first packet in a keybox blob "
	"is not a public key packet\n");
	err = gpg_error (GPG_ERR_INV_KEYRING);
	break;
	}
	if (in_cert && (pkt->pkttype == PKT_PUBLIC_KEY
	\|\| pkt->pkttype == PKT_SECRET_KEY))
	{
	log_error ("parse_keyblock_image: "
	"multiple keyblocks in a keybox blob\n");
	err = gpg_error (GPG_ERR_INV_KEYRING);
	break;
	}
	in_cert = 1;

	node = new_kbnode (pkt);

	switch (pkt->pkttype)
	{
	case PKT_PUBLIC_KEY:
	case PKT_PUBLIC_SUBKEY:
	case PKT_SECRET_KEY:
	case PKT_SECRET_SUBKEY:
	if (++pk_count == pk_no)
	node->flag \|= 1;
	break;

	case PKT_USER_ID:
	if (++uid_count == uid_no)
	node->flag \|= 2;
	break;

	default:
	break;
	}

	if (!keyblock)
	keyblock = node;
	else
	*tail = node;
	tail = &node->next;
	pkt = xtrymalloc (sizeof *pkt);
	if (!pkt)
	{
	err = gpg_error_from_syserror ();
	break;
	}
	init_packet (pkt);
	}
	set_packet_list_mode (save_mode);

	if (err == -1 && keyblock)
	err = 0; /* Got the entire keyblock. */

	if (err)
	release_kbnode (keyblock);
	else
	{
	*r_keyblock = keyblock;
	keydb_stats.parse_keyblocks++;
	}
	free_packet (pkt, &parsectx);
	deinit_parse_packet (&parsectx);
	xfree (pkt);
	return err;
	}


	/* Return the keyblock last found by keydb_search() in *RET_KB.
	* keydb_get_keyblock divert to here in the non-keyboxd mode.
	*
	* On success, the function returns 0 and the caller must free *RET_KB
	* using release_kbnode(). Otherwise, the function returns an error
	* code.
	*
	* The returned keyblock has the kbnode flag bit 0 set for the node
	* with the public key used to locate the keyblock or flag bit 1 set
	* for the user ID node. */
	gpg_error_t
	internal_keydb_get_keyblock (KEYDB_HANDLE hd, KBNODE *ret_kb)
	{
	gpg_error_t err = 0;

	log_assert (!hd->use_keyboxd);

	if (hd->keyblock_cache.state == KEYBLOCK_CACHE_FILLED)
	{
	err = iobuf_seek (hd->keyblock_cache.iobuf, 0);
	if (err)
	{
	log_error ("keydb_get_keyblock: failed to rewind iobuf for cache\n");
	keyblock_cache_clear (hd);
	}
	else
	{
	err = keydb_parse_keyblock (hd->keyblock_cache.iobuf,
	hd->keyblock_cache.pk_no,
	hd->keyblock_cache.uid_no,
	ret_kb);
	if (err)
	keyblock_cache_clear (hd);
	if (DBG_CLOCK)
	log_clock ("%s leave (cached mode)", __func__);
	return err;
	}
	}

	if (hd->found < 0 \|\| hd->found >= hd->used)
	return gpg_error (GPG_ERR_VALUE_NOT_FOUND);

	switch (hd->active[hd->found].type)
	{
	case KEYDB_RESOURCE_TYPE_NONE:
	err = gpg_error (GPG_ERR_GENERAL); /* oops */
	break;
	case KEYDB_RESOURCE_TYPE_KEYRING:
	err = keyring_get_keyblock (hd->active[hd->found].u.kr, ret_kb);
	break;
	case KEYDB_RESOURCE_TYPE_KEYBOX:
	{
	iobuf_t iobuf;
	int pk_no, uid_no;

	err = keybox_get_keyblock (hd->active[hd->found].u.kb,
	&iobuf, &pk_no, &uid_no);
	if (!err)
	{
	err = keydb_parse_keyblock (iobuf, pk_no, uid_no, ret_kb);
	if (!err && hd->keyblock_cache.state == KEYBLOCK_CACHE_PREPARED)
	{
	hd->keyblock_cache.state = KEYBLOCK_CACHE_FILLED;
	hd->keyblock_cache.iobuf = iobuf;
	hd->keyblock_cache.pk_no = pk_no;
	hd->keyblock_cache.uid_no = uid_no;
	}
	else
	{
	iobuf_close (iobuf);
	}
	}
	}
	break;
	}

	if (hd->keyblock_cache.state != KEYBLOCK_CACHE_FILLED)
	keyblock_cache_clear (hd);

	if (!err)
	keydb_stats.get_keyblocks++;

	return err;
	}


	/* Update the keyblock KB (i.e., extract the fingerprint and find the
	* corresponding keyblock in the keyring).
	* keydb_update_keyblock diverts to here in the non-keyboxd mode.
	*
	* This doesn't do anything if --dry-run was specified.
	*
	* Returns 0 on success. Otherwise, it returns an error code. Note:
	* if there isn't a keyblock in the keyring corresponding to KB, then
	* this function returns GPG_ERR_VALUE_NOT_FOUND.
	*
	* This function selects the matching record and modifies the current
	* file position to point to the record just after the selected entry.
	* Thus, if you do a subsequent search using HD, you should first do a
	* keydb_search_reset. Further, if the selected record is important,
	* you should use keydb_push_found_state and keydb_pop_found_state to
	* save and restore it. */
	gpg_error_t
	internal_keydb_update_keyblock (ctrl_t ctrl, KEYDB_HANDLE hd, kbnode_t kb)
	{
	gpg_error_t err;
	PKT_public_key *pk;
	KEYDB_SEARCH_DESC desc;
	size_t len;

	log_assert (!hd->use_keyboxd);
	+
	+ if (!hd->locked)
	+ return gpg_error (GPG_ERR_NOT_LOCKED);
	+
	pk = kb->pkt->pkt.public_key;

	kid_not_found_flush ();
	keyblock_cache_clear (hd);

	if (opt.dry_run)
	return 0;

	- err = lock_all (hd);
	- if (err)
	- return err;
	-
	#ifdef USE_TOFU
	tofu_notice_key_changed (ctrl, kb);
	#else
	(void)ctrl;
	#endif

	memset (&desc, 0, sizeof (desc));
	fingerprint_from_pk (pk, desc.u.fpr, &len);
	if (len == 20 \|\| len == 32)
	{
	desc.mode = KEYDB_SEARCH_MODE_FPR;
	desc.fprlen = len;
	}
	else
	log_bug ("%s: Unsupported key length: %zu\n", __func__, len);

	keydb_search_reset (hd);
	err = keydb_search (hd, &desc, 1, NULL);
	if (err)
	return gpg_error (GPG_ERR_VALUE_NOT_FOUND);
	log_assert (hd->found >= 0 && hd->found < hd->used);

	switch (hd->active[hd->found].type)
	{
	case KEYDB_RESOURCE_TYPE_NONE:
	err = gpg_error (GPG_ERR_GENERAL); /* oops */
	break;
	case KEYDB_RESOURCE_TYPE_KEYRING:
	err = keyring_update_keyblock (hd->active[hd->found].u.kr, kb);
	break;
	case KEYDB_RESOURCE_TYPE_KEYBOX:
	{
	iobuf_t iobuf;

	err = build_keyblock_image (kb, &iobuf);
	if (!err)
	{
	keydb_stats.build_keyblocks++;
	err = keybox_update_keyblock (hd->active[hd->found].u.kb,
	iobuf_get_temp_buffer (iobuf),
	iobuf_get_temp_length (iobuf));
	iobuf_close (iobuf);
	}
	}
	break;
	}

	- unlock_all (hd);
	if (!err)
	keydb_stats.update_keyblocks++;
	return err;
	}


	/* Insert a keyblock into one of the underlying keyrings or keyboxes.
	* keydb_insert_keyblock diverts to here in the non-keyboxd mode.
	*
	* Be default, the keyring / keybox from which the last search result
	* came is used. If there was no previous search result (or
	* keydb_search_reset was called), then the keyring / keybox where the
	* next search would start is used (i.e., the current file position).
	*
	* Note: this doesn't do anything if --dry-run was specified.
	*
	* Returns 0 on success. Otherwise, it returns an error code. */
	gpg_error_t
	internal_keydb_insert_keyblock (KEYDB_HANDLE hd, kbnode_t kb)
	{
	- gpg_error_t err;
	+ gpg_error_t err = 0;
	int idx;

	log_assert (!hd->use_keyboxd);

	+ if (!hd->locked)
	+ return gpg_error (GPG_ERR_NOT_LOCKED);
	+
	kid_not_found_flush ();
	keyblock_cache_clear (hd);

	if (opt.dry_run)
	return 0;

	if (hd->found >= 0 && hd->found < hd->used)
	idx = hd->found;
	else if (hd->current >= 0 && hd->current < hd->used)
	idx = hd->current;
	else
	return gpg_error (GPG_ERR_GENERAL);

	- err = lock_all (hd);
	- if (err)
	- return err;
	-
	switch (hd->active[idx].type)
	{
	case KEYDB_RESOURCE_TYPE_NONE:
	err = gpg_error (GPG_ERR_GENERAL); /* oops */
	break;
	case KEYDB_RESOURCE_TYPE_KEYRING:
	err = keyring_insert_keyblock (hd->active[idx].u.kr, kb);
	break;
	case KEYDB_RESOURCE_TYPE_KEYBOX:
	{ /* We need to turn our kbnode_t list of packets into a proper
	keyblock first. This is required by the OpenPGP key parser
	included in the keybox code. Eventually we can change this
	kludge to have the caller pass the image. */
	iobuf_t iobuf;

	err = build_keyblock_image (kb, &iobuf);
	if (!err)
	{
	keydb_stats.build_keyblocks++;
	err = keybox_insert_keyblock (hd->active[idx].u.kb,
	iobuf_get_temp_buffer (iobuf),
	iobuf_get_temp_length (iobuf));
	iobuf_close (iobuf);
	}
	}
	break;
	}

	- unlock_all (hd);
	if (!err)
	keydb_stats.insert_keyblocks++;
	return err;
	}


	/* Delete the currently selected keyblock. If you haven't done a
	* search yet on this database handle (or called keydb_search_reset),
	* then this will return an error.
	*
	* Returns 0 on success or an error code, if an error occurs. */
	gpg_error_t
	internal_keydb_delete_keyblock (KEYDB_HANDLE hd)
	{
	- gpg_error_t rc;
	+ gpg_error_t err = 0;

	log_assert (!hd->use_keyboxd);

	+ if (!hd->locked)
	+ return gpg_error (GPG_ERR_NOT_LOCKED);
	+
	kid_not_found_flush ();
	keyblock_cache_clear (hd);

	if (hd->found < 0 \|\| hd->found >= hd->used)
	return gpg_error (GPG_ERR_VALUE_NOT_FOUND);

	if (opt.dry_run)
	return 0;

	- rc = lock_all (hd);
	- if (rc)
	- return rc;
	-
	switch (hd->active[hd->found].type)
	{
	case KEYDB_RESOURCE_TYPE_NONE:
	- rc = gpg_error (GPG_ERR_GENERAL);
	+ err = gpg_error (GPG_ERR_GENERAL);
	break;
	case KEYDB_RESOURCE_TYPE_KEYRING:
	- rc = keyring_delete_keyblock (hd->active[hd->found].u.kr);
	+ err = keyring_delete_keyblock (hd->active[hd->found].u.kr);
	break;
	case KEYDB_RESOURCE_TYPE_KEYBOX:
	- rc = keybox_delete (hd->active[hd->found].u.kb);
	+ err = keybox_delete (hd->active[hd->found].u.kb);
	break;
	}

	- unlock_all (hd);
	- if (!rc)
	+ if (!err)
	keydb_stats.delete_keyblocks++;
	- return rc;
	+ return err;
	}



	/* A database may consists of multiple keyrings / key boxes. This
	* sets the "file position" to the start of the first keyring / key
	* box that is writable (i.e., doesn't have the read-only flag set).
	*
	* This first tries the primary keyring (the last keyring (not
	* keybox!) added using keydb_add_resource() and with
	* KEYDB_RESOURCE_FLAG_PRIMARY set). If that is not writable, then it
	* tries the keyrings / keyboxes in the order in which they were
	* added. */
	gpg_error_t
	keydb_locate_writable (KEYDB_HANDLE hd)
	{
	gpg_error_t rc;

	if (!hd)
	return GPG_ERR_INV_ARG;

	if (hd->use_keyboxd)
	return 0; /* No need for this here. */

	rc = keydb_search_reset (hd); /* this does reset hd->current */
	if (rc)
	return rc;

	/* If we have a primary set, try that one first */
	if (primary_keydb)
	{
	for ( ; hd->current >= 0 && hd->current < hd->used; hd->current++)
	{
	if(hd->active[hd->current].token == primary_keydb)
	{
	if(keyring_is_writable (hd->active[hd->current].token))
	return 0;
	else
	break;
	}
	}

	rc = keydb_search_reset (hd); /* this does reset hd->current */
	if (rc)
	return rc;
	}

	for ( ; hd->current >= 0 && hd->current < hd->used; hd->current++)
	{
	switch (hd->active[hd->current].type)
	{
	case KEYDB_RESOURCE_TYPE_NONE:
	BUG();
	break;
	case KEYDB_RESOURCE_TYPE_KEYRING:
	if (keyring_is_writable (hd->active[hd->current].token))
	return 0; /* found (hd->current is set to it) */
	break;
	case KEYDB_RESOURCE_TYPE_KEYBOX:
	if (keybox_is_writable (hd->active[hd->current].token))
	return 0; /* found (hd->current is set to it) */
	break;
	}
	}

	return gpg_error (GPG_ERR_NOT_FOUND);
	}


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

	if (opt.use_keyboxd)
	return; /* No need for this here. */

	for (i=0; i < used_resources; i++)
	{
	if (!keyring_is_writable (all_resources[i].token))
	continue;
	switch (all_resources[i].type)
	{
	case KEYDB_RESOURCE_TYPE_NONE: /* ignore */
	break;
	case KEYDB_RESOURCE_TYPE_KEYRING:
	rc = keyring_rebuild_cache (ctrl, all_resources[i].token,noisy);
	if (rc)
	log_error (_("failed to rebuild keyring cache: %s\n"),
	gpg_strerror (rc));
	break;
	case KEYDB_RESOURCE_TYPE_KEYBOX:
	/* N/A. */
	break;
	}
	}
	}


	/* Return the number of skipped blocks (because they were too large to
	read from a keybox) since the last search reset. */
	unsigned long
	keydb_get_skipped_counter (KEYDB_HANDLE hd)
	{
	/FIXME(keyboxd): Do we need this? /
	return hd && !hd->use_keyboxd? hd->skipped_long_blobs : 0;
	}


	/* Clears the current search result and resets the handle's position
	* so that the next search starts at the beginning of the database
	* (the start of the first resource).
	* keydb_search_reset diverts to here in the non-keyboxd mode.
	*
	* Returns 0 on success and an error code if an error occurred.
	* (Currently, this function always returns 0 if HD is valid.) */
	gpg_error_t
	internal_keydb_search_reset (KEYDB_HANDLE hd)
	{
	gpg_error_t rc = 0;
	int i;

	log_assert (!hd->use_keyboxd);

	keyblock_cache_clear (hd);

	hd->skipped_long_blobs = 0;
	hd->current = 0;
	hd->found = -1;
	/* Now reset all resources. */
	for (i=0; !rc && i < hd->used; i++)
	{
	switch (hd->active[i].type)
	{
	case KEYDB_RESOURCE_TYPE_NONE:
	break;
	case KEYDB_RESOURCE_TYPE_KEYRING:
	rc = keyring_search_reset (hd->active[i].u.kr);
	break;
	case KEYDB_RESOURCE_TYPE_KEYBOX:
	rc = keybox_search_reset (hd->active[i].u.kb);
	break;
	}
	}
	hd->is_reset = 1;
	if (!rc)
	keydb_stats.search_resets++;
	return rc;
	}


	/* Search the database for keys matching the search description. If
	* the DB contains any legacy keys, these are silently ignored.
	* keydb_search diverts to here in the non-keyboxd mode.
	*
	* DESC is an array of search terms with NDESC entries. The search
	* terms are or'd together. That is, the next entry in the DB that
	* matches any of the descriptions will be returned.
	*
	* Note: this function resumes searching where the last search left
	* off (i.e., at the current file position). If you want to search
	* from the start of the database, then you need to first call
	* keydb_search_reset().
	*
	* If no key matches the search description, returns
	* GPG_ERR_NOT_FOUND. If there was a match, returns 0. If an error
	* occurred, returns an error code.
	*
	* The returned key is considered to be selected and the raw data can,
	* for instance, be returned by calling keydb_get_keyblock(). */
	gpg_error_t
	internal_keydb_search (KEYDB_HANDLE hd, KEYDB_SEARCH_DESC *desc,
	size_t ndesc, size_t *descindex)
	{
	gpg_error_t rc;
	int was_reset = hd->is_reset;
	/* If an entry is already in the cache, then don't add it again. */
	int already_in_cache = 0;
	int fprlen;

	log_assert (!hd->use_keyboxd);

	if (!any_registered)
	{
	write_status_error ("keydb_search", gpg_error (GPG_ERR_KEYRING_OPEN));
	return gpg_error (GPG_ERR_NOT_FOUND);
	}

	if (ndesc == 1 && desc[0].mode == KEYDB_SEARCH_MODE_LONG_KID
	&& (already_in_cache = kid_not_found_p (desc[0].u.kid)) == 1 )
	{
	if (DBG_CLOCK)
	log_clock ("%s leave (not found, cached)", __func__);
	keydb_stats.notfound_cached++;
	return gpg_error (GPG_ERR_NOT_FOUND);
	}

	/* NB: If one of the exact search modes below is used in a loop to
	walk over all keys (with the same fingerprint) the caching must
	have been disabled for the handle. */
	if (desc[0].mode == KEYDB_SEARCH_MODE_FPR)
	fprlen = desc[0].fprlen;
	else
	fprlen = 0;

	if (!hd->no_caching
	&& ndesc == 1
	&& fprlen
	&& hd->keyblock_cache.state == KEYBLOCK_CACHE_FILLED
	&& hd->keyblock_cache.fprlen == fprlen
	&& !memcmp (hd->keyblock_cache.fpr, desc[0].u.fpr, fprlen)
	/* Make sure the current file position occurs before the cached
	result to avoid an infinite loop. */
	&& (hd->current < hd->keyblock_cache.resource
	\|\| (hd->current == hd->keyblock_cache.resource
	&& (keybox_offset (hd->active[hd->current].u.kb)
	<= hd->keyblock_cache.offset))))
	{
	/* (DESCINDEX is already set). */
	if (DBG_CLOCK)
	log_clock ("%s leave (cached)", __func__);

	hd->current = hd->keyblock_cache.resource;
	/* HD->KEYBLOCK_CACHE.OFFSET is the last byte in the record.
	Seek just beyond that. */
	keybox_seek (hd->active[hd->current].u.kb, hd->keyblock_cache.offset + 1);
	keydb_stats.found_cached++;
	return 0;
	}

	rc = -1;
	while ((rc == -1 \|\| gpg_err_code (rc) == GPG_ERR_EOF)
	&& hd->current >= 0 && hd->current < hd->used)
	{
	if (DBG_KEYDB)
	log_debug ("%s: searching %s (resource %d of %d)\n",
	__func__,
	hd->active[hd->current].type == KEYDB_RESOURCE_TYPE_KEYRING
	? "keyring"
	: (hd->active[hd->current].type == KEYDB_RESOURCE_TYPE_KEYBOX
	? "keybox" : "unknown type"),
	hd->current, hd->used);

	switch (hd->active[hd->current].type)
	{
	case KEYDB_RESOURCE_TYPE_NONE:
	BUG(); /* we should never see it here */
	break;
	case KEYDB_RESOURCE_TYPE_KEYRING:
	rc = keyring_search (hd->active[hd->current].u.kr, desc,
	ndesc, descindex, 1);
	break;
	case KEYDB_RESOURCE_TYPE_KEYBOX:
	do
	rc = keybox_search (hd->active[hd->current].u.kb, desc,
	ndesc, KEYBOX_BLOBTYPE_PGP,
	descindex, &hd->skipped_long_blobs);
	while (rc == GPG_ERR_LEGACY_KEY);
	break;
	}

	if (DBG_KEYDB)
	log_debug ("%s: searched %s (resource %d of %d) => %s\n",
	__func__,
	hd->active[hd->current].type == KEYDB_RESOURCE_TYPE_KEYRING
	? "keyring"
	: (hd->active[hd->current].type == KEYDB_RESOURCE_TYPE_KEYBOX
	? "keybox" : "unknown type"),
	hd->current, hd->used,
	rc == -1 ? "EOF" : gpg_strerror (rc));

	if (rc == -1 \|\| gpg_err_code (rc) == GPG_ERR_EOF)
	{
	/* EOF -> switch to next resource */
	hd->current++;
	}
	else if (!rc)
	hd->found = hd->current;
	}
	hd->is_reset = 0;

	rc = ((rc == -1 \|\| gpg_err_code (rc) == GPG_ERR_EOF)
	? gpg_error (GPG_ERR_NOT_FOUND)
	: rc);

	keyblock_cache_clear (hd);
	if (!hd->no_caching
	&& !rc
	&& ndesc == 1
	&& fprlen
	&& hd->active[hd->current].type == KEYDB_RESOURCE_TYPE_KEYBOX)
	{
	hd->keyblock_cache.state = KEYBLOCK_CACHE_PREPARED;
	hd->keyblock_cache.resource = hd->current;
	/* The current offset is at the start of the next record. Since
	a record is at least 1 byte, we just use offset - 1, which is
	within the record. */
	hd->keyblock_cache.offset
	= keybox_offset (hd->active[hd->current].u.kb) - 1;
	memcpy (hd->keyblock_cache.fpr, desc[0].u.fpr, fprlen);
	hd->keyblock_cache.fprlen = fprlen;
	}

	if (gpg_err_code (rc) == GPG_ERR_NOT_FOUND
	&& ndesc == 1
	&& desc[0].mode == KEYDB_SEARCH_MODE_LONG_KID
	&& was_reset
	&& !already_in_cache)
	kid_not_found_insert (desc[0].u.kid);

	if (!rc)
	keydb_stats.found++;
	else
	keydb_stats.notfound++;
	return rc;
	}


	/* Return the first non-legacy key in the database.
	*
	* If you want the very first key in the database, you can directly
	* call keydb_search with the search description
	* KEYDB_SEARCH_MODE_FIRST. */
	gpg_error_t
	keydb_search_first (KEYDB_HANDLE hd)
	{
	gpg_error_t err;
	KEYDB_SEARCH_DESC desc;

	err = keydb_search_reset (hd);
	if (err)
	return err;

	memset (&desc, 0, sizeof desc);
	desc.mode = KEYDB_SEARCH_MODE_FIRST;
	return keydb_search (hd, &desc, 1, NULL);
	}


	/* Return the next key (not the next matching key!).
	*
	* Unlike calling keydb_search with KEYDB_SEARCH_MODE_NEXT, this
	* function silently skips legacy keys. */
	gpg_error_t
	keydb_search_next (KEYDB_HANDLE hd)
	{
	KEYDB_SEARCH_DESC desc;

	memset (&desc, 0, sizeof desc);
	desc.mode = KEYDB_SEARCH_MODE_NEXT;
	return keydb_search (hd, &desc, 1, NULL);
	}


	/* This is a convenience function for searching for keys with a long
	* key id.
	*
	* Note: this function resumes searching where the last search left
	* off. If you want to search the whole database, then you need to
	* first call keydb_search_reset(). */
	gpg_error_t
	keydb_search_kid (KEYDB_HANDLE hd, u32 *kid)
	{
	KEYDB_SEARCH_DESC desc;

	memset (&desc, 0, sizeof desc);
	desc.mode = KEYDB_SEARCH_MODE_LONG_KID;
	desc.u.kid[0] = kid[0];
	desc.u.kid[1] = kid[1];
	return keydb_search (hd, &desc, 1, NULL);
	}


	/* This is a convenience function for searching for keys with a long
	* (20 byte) fingerprint.
	*
	* Note: this function resumes searching where the last search left
	* off. If you want to search the whole database, then you need to
	* first call keydb_search_reset(). */
	gpg_error_t
	keydb_search_fpr (KEYDB_HANDLE hd, const byte *fpr, size_t fprlen)
	{
	KEYDB_SEARCH_DESC desc;

	memset (&desc, 0, sizeof desc);
	desc.mode = KEYDB_SEARCH_MODE_FPR;
	memcpy (desc.u.fpr, fpr, fprlen);
	desc.fprlen = fprlen;
	return keydb_search (hd, &desc, 1, NULL);
	}
	diff --git a/g10/keyedit.c b/g10/keyedit.c
	index 0c54a448b..bae79b37e 100644
	--- a/g10/keyedit.c
	+++ b/g10/keyedit.c
	@@ -1,7214 +1,7217 @@
	/* 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, 2022-2023 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 "../common/mbox-util.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 maybe_upload_key (ctrl_t ctrl, kbnode_t keyblock);
	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, unsigned int options);
	static void menu_delkey (KBNODE pub_keyblock);
	static int menu_addrevoker (ctrl_t ctrl, kbnode_t pub_keyblock, int sensitive);
	static int menu_addadsk (ctrl_t ctrl, kbnode_t pub_keyblock,
	const char *adskfpr);
	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,
	int unattended);
	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)

	/* Flags values used by sign_uids(). */
	#define SIGN_UIDS_LOCAL 1 /* Create non-exportable sig. */
	#define SIGN_UIDS_NONREVOCABLE 2 /* Create non-revocable sig. */
	#define SIGN_UIDS_TRUSTSIG 4 /* Create trust signature. */
	#define SIGN_UIDS_INTERACTIVE 8 /* Change the way of prompting. */
	#define SIGN_UIDS_QUICK 16 /* Called by a --quick command. */

	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) +
	((opt.
	list_options & LIST_SHOW_HIDDEN_NOTATIONS) ? 4: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, 1, SIGSUBPKT_PRIMARY_UID, NULL);
	if (s && *s)
	tty_fprintf (fp, " [primary]\n");

	s = parse_sig_subpkt (sig, 1, 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;
	}


	/* Parse a trust signature specification string into the 3 return
	* args. Returns 0 on success or an errorcode. Format for the string
	* is
	* ['T=']<depth>,<value>[,<domain>]
	* The optional prefix is just to allow c+p from the --check-sigs
	* output. The domain is optional, <depth> must be a value in the
	* range 0 to 255, value may either be value in the same range or -
	* preferred - 'm' or 'f'.
	*/
	static gpg_error_t
	parse_trustsig_string (const char *string,
	byte trust_value, byte trust_depth, char **regexp)
	{
	gpg_error_t err = 0;
	char **fields;
	int nfields;
	int along;
	char *endp;

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

	if (!string)
	return gpg_error (GPG_ERR_INV_ARG);

	if (*string == 'T' && string[1] == '=')
	string += 2;

	fields = strtokenize (string, ",");
	if (!fields)
	return gpg_error_from_syserror ();

	for (nfields=0; fields[nfields]; nfields++)
	;
	if (nfields < 2 \|\| nfields > 3)
	{
	err = gpg_error (GPG_ERR_SYNTAX);
	goto leave;
	}
	along = strtol (fields[0], &endp, 10);
	if (along < 0 \|\| along > 255 \|\| fields[0] == endp \|\| *endp)
	{
	err = gpg_error (GPG_ERR_ERANGE);
	goto leave;
	}
	*trust_depth = along;
	if (!strcmp (fields[1], "m")\|\| !strcmp (fields[1], "marginal"))
	along = 60;
	else if (!strcmp (fields[1], "f")\|\| !strcmp (fields[1], "full"))
	along = 120;
	else
	{
	along = strtol (fields[1], &endp, 10);
	if (along < 0 \|\| along > 255 \|\| fields[1] == endp \|\| *endp)
	{
	err = gpg_error (GPG_ERR_ERANGE);
	goto leave;
	}
	}
	*trust_value = along;

	if (nfields == 3)
	{
	if (!is_valid_domain_name (fields[2]))
	err = gpg_error (GPG_ERR_NO_NAME);
	else
	{
	*regexp = strconcat ("<[^>]+[@.]", fields[2], ">$", NULL);
	if (!*regexp)
	err = gpg_error_from_syserror ();
	}
	}

	leave:
	xfree (fields);
	if (err && *regexp)
	{
	xfree (*regexp);
	*regexp = NULL;
	}
	return err;
	}


	/* Interactive version of parse_trustsig_string. */
	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. FLAGS are the SIGN_UIDS_* constants.
	* For example with SIGN_UIDS_QUICK the function won't ask the user
	* and use sensible defaults. TRUSTSIGSTR is only used if also
	* SIGN_UIDS_TRUSTSIG is set.
	*/
	static int
	sign_uids (ctrl_t ctrl, estream_t fp,
	kbnode_t keyblock, strlist_t locusr, unsigned int flags,
	const char trustsigstr, int ret_modified)
	{
	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;
	char *trust_regexp = NULL;
	int select_all = (!count_selected_uids (keyblock)
	\|\| (flags & SIGN_UIDS_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;
	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 && !(flags & SIGN_UIDS_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 ((flags & SIGN_UIDS_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 && !(flags & SIGN_UIDS_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 ((flags & SIGN_UIDS_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 && !(flags & SIGN_UIDS_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 ((flags & SIGN_UIDS_INTERACTIVE))
	yesreally = 1;
	}
	else
	{
	uidnode->flag &= ~NODFLG_MARK_A;
	uidnode = NULL;
	tty_fprintf (fp, _(" Unable to sign.\n"));
	}
	}

	if (uidnode && (flags & SIGN_UIDS_INTERACTIVE)
	&& !yesreally && !(flags & SIGN_UIDS_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 && !(flags & SIGN_UIDS_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 ((flags & SIGN_UIDS_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
	&& !(flags & SIGN_UIDS_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 ((flags & SIGN_UIDS_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
	&& (flags & SIGN_UIDS_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 (node->pkt->pkt.signature->digest_algo
	== DIGEST_ALGO_SHA1
	&& !opt.flags.allow_weak_key_signatures)
	{
	/* Allow updating a signature to a stronger
	* digest algorithm without an extra option. */
	xfree (user);
	continue;
	}
	else if (opt.flags.force_sign_key
	\|\| (opt.expert && !(flags & SIGN_UIDS_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 && !(flags & SIGN_UIDS_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 && !(flags & SIGN_UIDS_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 && !(flags & SIGN_UIDS_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 \|\| (flags & SIGN_UIDS_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 ((flags & SIGN_UIDS_TRUSTSIG))
	{
	xfree (trust_regexp);
	trust_regexp = NULL;
	if ((flags & SIGN_UIDS_QUICK))
	{
	rc = parse_trustsig_string (trustsigstr, &trust_value,
	&trust_depth, &trust_regexp);
	if (rc)
	goto leave;
	}
	else
	trustsig_prompt (&trust_value, &trust_depth, &trust_regexp);
	}
	}

	if (!(flags & SIGN_UIDS_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 ((flags & SIGN_UIDS_LOCAL))
	{
	tty_fprintf (fp, "\n");
	tty_fprintf (fp, _("WARNING: the signature will not be marked "
	"as non-exportable.\n"));
	}

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

	if ((flags & SIGN_UIDS_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 ((flags & SIGN_UIDS_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 = !!(flags & SIGN_UIDS_LOCAL);
	attrib.non_revocable = !!(flags & SIGN_UIDS_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,
	keygen_add_std_prefs, primary_pk,
	NULL);
	else
	rc = make_keysig_packet (ctrl, &sig, primary_pk,
	node->pkt->pkt.user_id,
	NULL,
	pk,
	class,
	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:
	xfree (trust_regexp);
	trust_regexp = NULL;
	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;
	/* FIXME: Handle dual keys. */
	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_LOGLVL_INFO : GPGRT_LOGLVL_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 (collapse_subkeys (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;
	}


	/* Helper to parse the prefix of the sign command STR and set the
	* respective bits in R_FLAGS. Returns false on error. */
	static int
	parse_sign_type (const char str, unsigned int r_flags)
	{
	const char *p = str;

	while (*p)
	{
	if (ascii_strncasecmp (p, "l", 1) == 0)
	{
	*r_flags \|= SIGN_UIDS_LOCAL;
	p++;
	}
	else if (ascii_strncasecmp (p, "nr", 2) == 0)
	{
	*r_flags \|= SIGN_UIDS_NONREVOCABLE;
	p += 2;
	}
	else if (ascii_strncasecmp (p, "t", 1) == 0)
	{
	*r_flags \|= SIGN_UIDS_TRUSTSIG;
	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, cmdADDADSK,
	#ifndef NO_TRUST_MODELS
	cmdENABLEKEY, cmdDISABLEKEY,
	#endif /!NO_TRUST_MODELS/
	cmdSHOWPREF,
	cmdSETPREF, cmdPREFKS, cmdNOTATION, cmdINVCMD, cmdSHOWPHOTO, cmdUPDTRUST,
	cmdCHKTRUST, cmdADDCARDKEY, cmdKEYTOCARD, cmdKEYTOTPM, 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")},
	{ "keytotpm", cmdKEYTOTPM, KEYEDIT_NEED_SK \| KEYEDIT_NEED_SUBSK,
	N_("convert a key to TPM form using the local TPM")},
	{ "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")},
	{ "addadsk", cmdADDADSK, KEYEDIT_NEED_SK,
	N_("add an additional decryption subkey")},
	{ "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 upload = 0; /* Set if the key maybe be uploaded. */
	int sec_shadowing = 0;
	int run_subkey_warnings = 0;
	int have_commands = !!commands;
	strlist_t delseckey_list = NULL;
	int delseckey_list_warn = 0;

	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 through 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);
	no_usable_encr_subkeys_warning (keyblock);
	}

	if (delseckey_list_warn)
	{
	delseckey_list_warn = 0;
	tty_printf
	(_("Note: the local copy of the secret key"
	" will only be deleted with \"save\".\n"));
	}

	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:
	{
	unsigned int myflags = 0;
	int my_modified = 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)
	myflags \|= SIGN_UIDS_INTERACTIVE;
	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, &myflags))
	{
	tty_printf (_("Unknown signature type '%s'\n"), answer);
	break;
	}

	sign_uids (ctrl, NULL, keyblock, locusr, myflags,
	NULL, &my_modified);
	if (my_modified) /* sign_uids modified the keyblock */
	modified = 1; /* thus set the general modified flag. */
	if (my_modified && !(myflags & SIGN_UIDS_LOCAL))
	upload = 1; /* exportable signature -> mark uploadable. */
	}
	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;
	upload = 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;
	/* upload does not make sense here. Eventually we may
	* decide to delete a key from the keyserver.*/
	}
	}
	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;
	upload = 1;
	merge_keys_and_selfsig (ctrl, keyblock);
	}
	break;

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

	case cmdKEYTOTPM:
	/* FIXME need to store the key and not commit until later */
	{
	kbnode_t 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;
	char *hexgrip;

	hexkeygrip_from_pk (xxpk, &hexgrip);
	if (!agent_keytotpm (ctrl, hexgrip))
	{
	redisplay = 1;
	}
	xfree (hexgrip);
	}
	}
	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,
	&delseckey_list))
	{
	redisplay = 1;
	sec_shadowing = 1;
	delseckey_list_warn = 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;
	int lastmode;

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

	err = agent_set_ephemeral_mode (ctrl, 1, &lastmode);
	if (err)
	log_error ("error switching to ephemeral mode: %s\n",
	gpg_strerror (err));
	else
	{
	/* Transfer it to gpg-agent which handles secret keys. */
	err = transfer_secret_keys (ctrl, NULL, node, 1, 1, 0);
	if (!err)
	{
	/* 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, NULL))
	{
	redisplay = 1;
	sec_shadowing = 1;
	}
	}
	if (!lastmode && agent_set_ephemeral_mode (ctrl, 0, NULL))
	log_error ("error clearing the ephemeral mode\n");
	}
	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;
	/* upload does not make sense. */
	}
	}
	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;
	upload = 1;
	merge_keys_and_selfsig (ctrl, keyblock);
	}
	}
	break;

	case cmdADDADSK:
	if (menu_addadsk (ctrl, keyblock, NULL))
	{
	redisplay = 1;
	modified = 1;
	upload = 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;
	upload = 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;
	upload = 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;
	upload = 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;
	upload = 1;
	redisplay = 1;
	}
	break;

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

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

	case cmdPRIMARY:
	if (menu_set_primary_uid (ctrl, keyblock))
	{
	merge_keys_and_selfsig (ctrl, keyblock);
	modified = 1;
	upload = 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, 0))
	{
	merge_keys_and_selfsig (ctrl, keyblock);
	modified = 1;
	upload = 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;
	upload = 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;
	upload = 1;
	redisplay = 1;
	}
	break;

	case cmdNOP:
	break;

	case cmdREVSIG:
	if (menu_revsig (ctrl, keyblock))
	{
	redisplay = 1;
	modified = 1;
	upload = 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, EXPORT_MINIMAL))
	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 (upload)
	{
	maybe_upload_key (ctrl, keyblock);
	upload = 0;
	}
	}

	if (delseckey_list)
	{
	strlist_t sl;
	for (err = 0, sl = delseckey_list; sl; sl = sl->next)
	{
	if (*sl->d)
	{
	err = agent_delete_key (ctrl, sl->d, NULL, 1/force/);
	if (err)
	break;
	sl->d = 0; / Mark deleted. */
	}
	}
	if (err)
	{
	log_error (_("deleting copy of secret key failed: %s\n"),
	gpg_strerror (err));
	break; /* the "save". */
	}
	}

	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:
	free_strlist (delseckey_list);
	release_kbnode (keyblock);
	keydb_release (kdbhd);
	xfree (answer);
	}


	/* Helper to upload a key to an LDAP server if configured. */
	static void
	maybe_upload_key (ctrl_t ctrl, kbnode_t keyblock)
	{
	unsigned int saved_options;

	if (!opt.flags.auto_key_upload)
	return;

	saved_options = opt.keyserver_options.options;
	opt.keyserver_options.options \|= KEYSERVER_LDAP_ONLY;
	opt.keyserver_options.options \|= KEYSERVER_WARN_ONLY;
	keyserver_export_pubkey (ctrl, keyblock->pkt->pkt.public_key, 0);
	opt.keyserver_options.options = saved_options;
	}


	/* 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, int want_secret,
	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 (ctrl);
	if (!kdbhd)
	{
	/* Note that keydb_new has already used log_error. */
	err = gpg_error_from_syserror ();
	goto leave;
	}
	+ err = keydb_lock (kdbhd);
	+ if (err)
	+ 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 && want_secret)
	{
	/* We require the secret primary key to set the primary UID. */
	node = find_kbnode (keyblock, PKT_PUBLIC_KEY);
	log_assert (node);
	if (!agent_probe_secret_key (ctrl, node->pkt->pkt.public_key))
	err = gpg_error (GPG_ERR_NO_SECKEY);
	}
	}
	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, 1, &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;
	}
	maybe_upload_key (ctrl, keyblock);
	if (update_trust)
	revalidation_mark (ctrl);
	}

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


	/* Helper to find the UID node for namehash. On success, returns the UID node.
	Otherwise, return NULL. */
	kbnode_t
	find_userid_by_namehash (kbnode_t keyblock, const char *namehash, int want_valid)
	{
	byte hash[NAMEHASH_LEN];
	kbnode_t node = NULL;

	if (!namehash)
	goto leave;

	if (strlen (namehash) != NAMEHASH_LEN * 2)
	goto leave;

	if (hex2bin (namehash, hash, NAMEHASH_LEN) < 0)
	goto leave;

	for (node = keyblock; node; node = node->next)
	{
	if (node->pkt->pkttype == PKT_USER_ID
	&& (!want_valid \|\| (!node->pkt->pkt.user_id->flags.revoked
	&& !node->pkt->pkt.user_id->flags.expired)))
	{
	namehash_from_uid (node->pkt->pkt.user_id);
	if (!memcmp (node->pkt->pkt.user_id->namehash, hash, NAMEHASH_LEN))
	break;
	}
	}

	leave:
	return node;
	}


	/* Helper to find the UID node for uid. On success, returns the UID node.
	Otherwise, return NULL. */
	kbnode_t
	find_userid (kbnode_t keyblock, const char *uid, int want_valid)
	{
	kbnode_t node = NULL;
	size_t uidlen;

	if (!keyblock \|\| !uid)
	goto leave;

	/* First try to find UID by namehash. */
	node = find_userid_by_namehash (keyblock, uid, want_valid);
	if (node)
	goto leave;

	uidlen = strlen (uid);
	for (node = keyblock; node; node = node->next)
	{
	if (node->pkt->pkttype == PKT_USER_ID
	&& (!want_valid \|\| (!node->pkt->pkt.user_id->flags.revoked
	&& !node->pkt->pkt.user_id->flags.expired))
	&& uidlen == node->pkt->pkt.user_id->len
	&& !memcmp (node->pkt->pkt.user_id->name, uid, uidlen))
	break;
	}

	leave:
	return node;
	}


	/* 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 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, 1, &kdbhd, &keyblock);
	if (err)
	goto leave;

	/* To 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. */
	node = find_userid (keyblock, uidtorev, 0);
	if (node)
	{
	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;
	}
	maybe_upload_key (ctrl, keyblock);
	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 primarynode;
	kbnode_t node;

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

	err = quick_find_keyblock (ctrl, username, 1, &kdbhd, &keyblock);
	if (err)
	{
	write_status_error ("keyedit.primary", err);
	goto leave;
	}

	/* Find the first matching UID that is valid */
	primarynode = find_userid (keyblock, primaryuid, 1);

	/* and mark it. */
	if (primarynode)
	for (node = keyblock; node; node = node->next)
	{
	if (node == primarynode)
	node->flag \|= NODFLG_SELUID;
	else
	node->flag &= ~NODFLG_SELUID;
	}

	if (!primarynode)
	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;
	}
	maybe_upload_key (ctrl, keyblock);
	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));
	write_status_error ("keyedit.primary", err);
	}

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


	/* Unattended updating of the preference tro the standard preferences.
	* USERNAME specifies the key. This is basically the same as
	* gpg --edit-key <<userif> updpref save
	*/
	void
	keyedit_quick_update_pref (ctrl_t ctrl, const char *username)
	{
	gpg_error_t err;
	KEYDB_HANDLE kdbhd = NULL;
	kbnode_t keyblock = NULL;

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

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

	if (menu_set_preferences (ctrl, keyblock, 1))
	{
	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;
	}
	maybe_upload_key (ctrl, keyblock);
	}

	leave:
	if (err)
	write_status_error ("keyedit.updpref", err);
	release_kbnode (keyblock);
	keydb_release (kdbhd);
	}


	/* Unattended updating of the ownertrust or disable/enable state of a key
	* USERNAME specifies the key. This is somewhat similar to
	* gpg --edit-key <userid> trust save
	* gpg --edit-key <userid> disable save
	*
	* VALUE is the new trust value which is one of:
	* "undefined" - Ownertrust is set to undefined
	* "never" - Ownertrust is set to never trust
	* "marginal" - Ownertrust is set to marginal trust
	* "full" - Ownertrust is set to full trust
	* "ultimate" - Ownertrust is set to ultimate trust
	* "enable" - The key is re-enabled.
	* "disable" - The key is disabled.
	* Trust settings do not change the ebable/disable state.
	*/
	void
	keyedit_quick_set_ownertrust (ctrl_t ctrl, const char *username,
	const char *value)
	{
	gpg_error_t err;
	KEYDB_HANDLE kdbhd = NULL;
	kbnode_t keyblock = NULL;
	PKT_public_key *pk;
	unsigned int trust, newtrust;
	int x;
	int maybe_update_trust = 0;

	#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. Note
	* that we are looking for the public key here. */
	err = quick_find_keyblock (ctrl, username, 0, &kdbhd, &keyblock);
	if (err)
	goto leave;
	log_assert (keyblock->pkt->pkttype == PKT_PUBLIC_KEY
	\|\| keyblock->pkt->pkttype == PKT_SECRET_KEY);
	pk = keyblock->pkt->pkt.public_key;

	trust = newtrust = get_ownertrust (ctrl, pk);

	if (!ascii_strcasecmp (value, "enable"))
	newtrust &= ~TRUST_FLAG_DISABLED;
	else if (!ascii_strcasecmp (value, "disable"))
	newtrust \|= TRUST_FLAG_DISABLED;
	else if ((x = string_to_trust_value (value)) >= 0)
	{
	newtrust = x;
	newtrust &= TRUST_MASK;
	newtrust \|= (trust & ~TRUST_MASK);
	maybe_update_trust = 1;
	}
	else
	{
	err = gpg_error (GPG_ERR_INV_ARG);
	goto leave;
	}

	if (trust != newtrust)
	{
	update_ownertrust (ctrl, pk, newtrust);
	if (maybe_update_trust)
	revalidation_mark (ctrl);
	}
	else if (opt.verbose)
	log_info (_("Key not changed so no update needed.\n"));

	leave:
	if (err)
	{
	log_error (_("setting the ownertrust to '%s' failed: %s\n"),
	value, gpg_strerror (err));
	write_status_error ("keyedit.setownertrust", err);
	}
	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)
	{
	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 (desc.mode == KEYDB_SEARCH_MODE_FPR
	&& fprlen == desc.fprlen
	&& !memcmp (fprbin, desc.u.fpr, fprlen))
	;
	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 specified 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. If
	TRUSTSIG is given a trust signature is created; see
	parse_trustsig_string(). */
	void
	keyedit_quick_sign (ctrl_t ctrl, const char *fpr, strlist_t uids,
	strlist_t locusr, const char *trustsig, int local)
	{
	gpg_error_t err = 0;
	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

	/* Do an early check on an arg for an immediate error message. */
	if (trustsig)
	{
	byte trust_depth, trust_value;
	char *trust_regexp;
	err = parse_trustsig_string (trustsig, &trust_value,
	&trust_depth, &trust_regexp);
	xfree (trust_regexp);
	(void)trust_depth;
	(void)trust_value;
	if (err)
	goto leave;
	}

	/* 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"));
	err = gpg_error (GPG_ERR_CERT_REVOKED);
	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"));
	err = gpg_error (GPG_ERR_NO_USER_ID);
	goto leave;
	}

	/* Sign. */
	err = sign_uids (ctrl, es_stdout, keyblock, locusr,
	(SIGN_UIDS_QUICK
	\| (local? SIGN_UIDS_LOCAL : 0)
	\| (trustsig? SIGN_UIDS_TRUSTSIG : 0)),
	trustsig, &modified);
	es_fflush (es_stdout);
	if (err)
	goto leave;

	if (modified)
	{
	err = keydb_update_keyblock (ctrl, kdbhd, keyblock);
	if (err)
	{
	log_error (_("update failed: %s\n"), gpg_strerror (err));
	goto leave;
	}
	if (!local) /* No need to upload new non-expotable sigs. */
	maybe_upload_key (ctrl, keyblock);
	}
	else
	log_info (_("Key not changed so no update needed.\n"));

	if (update_trust)
	revalidation_mark (ctrl);

	leave:
	if (err)
	{
	log_error (_("creating key signature failed: %s\n"), gpg_strerror (err));
	write_status_error ("keyedit.sign-key", err);
	}
	release_kbnode (keyblock);
	keydb_release (kdbhd);
	}


	/* Unattended revocation of a key signatures. USERNAME specifies the
	* key; this should best be a fingerprint. SIGTOREV is the user-id of
	* the key for which the key signature shall be removed. Only
	* non-self-signatures can be removed with this functions. If
	* AFFECTED_UIDS is not NULL only the key signatures on these user-ids
	* are revoked. */
	void
	keyedit_quick_revsig (ctrl_t ctrl, const char username, const char sigtorev,
	strlist_t affected_uids)
	{
	gpg_error_t err = 0;
	int no_signing_key = 0;
	KEYDB_HANDLE kdbhd = NULL;
	kbnode_t keyblock = NULL;
	PKT_public_key primarypk; / Points into KEYBLOCK. */
	u32 *primarykid;
	PKT_public_key *pksigtorev = NULL;
	u32 *pksigtorevkid;
	kbnode_t node, n;
	int skip_remaining;
	int consider_sig;
	strlist_t sl;
	struct sign_attrib attrib = { 0 };

	#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. Note
	* that we are looking for the public key here. */
	err = quick_find_keyblock (ctrl, username, 0, &kdbhd, &keyblock);
	if (err)
	goto leave;
	log_assert (keyblock->pkt->pkttype == PKT_PUBLIC_KEY
	\|\| keyblock->pkt->pkttype == PKT_SECRET_KEY);
	primarypk = keyblock->pkt->pkt.public_key;
	primarykid = pk_keyid (primarypk);

	/* Get the signing key we want to revoke. This must be one of our
	* signing keys. We will compare only the keyid because we don't
	* assume that we have duplicated keyids on our own secret keys. If
	* a there is a duplicated one we will notice this when creating the
	* revocation. */
	pksigtorev = xtrycalloc (1, sizeof *pksigtorev);
	if (!pksigtorev)
	{
	err = gpg_error_from_syserror ();
	goto leave;
	}
	pksigtorev->req_usage = PUBKEY_USAGE_CERT;
	err = getkey_byname (ctrl, NULL, pksigtorev, sigtorev, 1, NULL);
	if (err)
	{
	no_signing_key = 1;
	goto leave;
	}
	pksigtorevkid = pk_keyid (pksigtorev);

	/* Find the signatures we want to revoke and set a mark. */
	skip_remaining = consider_sig = 0;
	for (node = keyblock; node; node = node->next)
	{
	node->flag &= ~NODFLG_MARK_A;
	if (skip_remaining)
	;
	else if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
	skip_remaining = 1;
	else if (node->pkt->pkttype == PKT_USER_ID)
	{
	PKT_user_id *uid = node->pkt->pkt.user_id;

	consider_sig = !affected_uids;
	for (sl = affected_uids; !consider_sig && sl; sl = sl->next)
	{
	const char *name = sl->d;

	if (uid->attrib_data)
	;
	else if (*name == '='
	&& strlen (name+1) == uid->len
	&& !memcmp (uid->name, name + 1, uid->len))
	{ /* Exact match. */
	consider_sig = 1;
	}
	else if (ascii_memistr (uid->name, uid->len,
	name == ''? name+1:name))
	{ /* Case-insensitive substring match. */
	consider_sig = 1;
	}
	}
	}
	else if (node->pkt->pkttype == PKT_SIGNATURE)
	{
	/* We need to sort the signatures so that we can figure out
	* whether the key signature has been revoked or the
	* revocation has been superseded by a new key
	* signature. */
	PKT_signature *sig;
	unsigned int sigcount = 0;
	kbnode_t *sigarray;

	/* Allocate an array large enough for all signatures. */
	for (n=node; n && n->pkt->pkttype == PKT_SIGNATURE; n = n->next)
	sigcount++;
	sigarray = xtrycalloc (sigcount, sizeof *sigarray);
	if (!sigarray)
	{
	err = gpg_error_from_syserror ();
	goto leave;
	}

	/* Now fill the array with signatures we are interested in.
	* We also move NODE forward to the end. */
	sigcount = 0;
	for (n=node; n && n->pkt->pkttype == PKT_SIGNATURE; node=n, n=n->next)
	{
	sig = n->pkt->pkt.signature;
	if (!keyid_cmp (primarykid, sig->keyid))
	continue; /* Ignore self-signatures. */

	if (keyid_cmp (pksigtorevkid, sig->keyid))
	continue; /* Ignore non-matching signatures. */

	n->flag &= ~NODFLG_MARK_B; /* Clear flag used by cm_signode. */
	sigarray[sigcount++] = n;
	}

	if (sigcount)
	{
	qsort (sigarray, sigcount, sizeof *sigarray, cmp_signodes);

	/* log_debug ("Sorted signatures:\n"); */
	/* for (idx=0; idx < sigcount; idx++) */
	/* { */
	/* sig = sigarray[idx]->pkt->pkt.signature; */
	/* log_debug ("%s 0x%02x %s\n", keystr (sig->keyid), */
	/* sig->sig_class, datestr_from_sig (sig)); */
	/* } */
	sig = sigarray[sigcount-1]->pkt->pkt.signature;
	if ((consider_sig \|\| !affected_uids) && IS_UID_REV (sig))
	{
	if (!opt.quiet)
	log_info ("sig by %s already revoked at %s\n",
	keystr (sig->keyid), datestr_from_sig (sig));
	}
	else if ((consider_sig && IS_UID_SIG (sig))
	\|\| (!affected_uids && IS_KEY_SIG (sig)))
	node->flag \|= NODFLG_MARK_A; /* Select signature. */
	}

	xfree (sigarray);
	}
	}

	/* Check whether any signatures were done by the given key. We do
	* not return an error if none were found. */
	for (node = keyblock; node; node = node->next)
	if ((node->flag & NODFLG_MARK_A))
	break;
	if (!node)
	{
	if (opt.verbose)
	log_info (_("Not signed by you.\n"));
	err = 0;
	goto leave;
	}

	/* Revoke all marked signatures. */
	attrib.reason = get_default_sig_revocation_reason ();

	reloop: /* (we must repeat because we are modifying the list) */
	for (node = keyblock; node; node = node->next)
	{
	kbnode_t unode;
	PKT_signature *sig;
	PACKET *pkt;

	if (!(node->flag & NODFLG_MARK_A))
	continue;
	node->flag &= ~NODFLG_MARK_A;

	if (IS_KEY_SIG (node->pkt->pkt.signature))
	unode = NULL;
	else
	{
	unode = find_prev_kbnode (keyblock, node, PKT_USER_ID);
	log_assert (unode);
	}

	attrib.non_exportable = !node->pkt->pkt.signature->flags.exportable;

	err = make_keysig_packet (ctrl, &sig, primarypk,
	unode? unode->pkt->pkt.user_id : NULL,
	NULL, pksigtorev, 0x30, 0, 0,
	sign_mk_attrib, &attrib, NULL);
	if (err)
	{
	log_error ("signing failed: %s\n", gpg_strerror (err));
	goto leave;
	}

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

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

	leave:
	if (err)
	{
	log_error (_("revoking the key signature failed: %s\n"),
	gpg_strerror (err));
	if (no_signing_key)
	print_further_info ("error getting key used to make the key signature");
	write_status_error ("keyedit.revoke.sig", err);
	}
	release_revocation_reason_info (attrib.reason);
	free_public_key (pksigtorev);
	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 ((err=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");
	err = gpg_error (GPG_ERR_CERT_REVOKED);
	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;
	}
	maybe_upload_key (ctrl, keyblock);
	}
	else
	log_info (_("Key not changed so no update needed.\n"));

	leave:
	if (err)
	write_status_error ("keyedit.addkey", err);
	release_kbnode (keyblock);
	keydb_release (kdbhd);
	}


	/* Unattended ADSK setup function.
	*
	* FPR is the fingerprint of our key. ADSKFPR is the fingerprint of
	* another subkey which we want to add as ADSK to our key.
	*/
	void
	keyedit_quick_addadsk (ctrl_t ctrl, const char fpr, const char adskfpr)
	{
	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 adsk
	* adding. */
	if ((err = 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");
	err = gpg_error (GPG_ERR_CERT_REVOKED);
	goto leave;
	}

	/* Locate and add the ADSK. Note that the called function already
	* prints error messages. */
	if (adskfpr && !ascii_strcasecmp (adskfpr, "default"))
	{
	err = append_all_default_adsks (ctrl, keyblock);
	if (!err)
	modified = 1;
	else if (gpg_err_code (err) == GPG_ERR_FALSE)
	err = 0;
	}
	else if (menu_addadsk (ctrl, keyblock, adskfpr))
	modified = 1;
	else
	log_inc_errorcount (); /* (We use log_info in menu_adsk) */

	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;
	}
	maybe_upload_key (ctrl, keyblock);
	}

	leave:
	if (err)
	write_status_error ("keyedit.addadsk", err);
	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 with only the 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)
	{
	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 == desc.fprlen && !memcmp (fprbin, desc.u.fpr, fprlen))
	{
	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;
	}
	maybe_upload_key (ctrl, keyblock);
	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)
	{
	if (!uid)
	return;

	if (verbose)
	{
	show_preferences (uid, 4, -1, 1);

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

	pref_ks = parse_sig_subpkt (selfsig, 1,
	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
	{
	show_preferences (uid, 4, -1, 0);
	}
	}


	/* 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);
	if ((pk->pubkey_usage & PUBKEY_USAGE_RENC))
	es_putc ('r', fp);
	if ((pk->pubkey_usage & PUBKEY_USAGE_TIME))
	es_putc ('t', fp);
	if ((pk->pubkey_usage & PUBKEY_USAGE_GROUP))
	es_putc ('g', fp);
	es_putc ('\n', fp);

	print_fingerprint (ctrl, fp, pk, 0);
	print_revokers (fp, 1, 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.aead)
	es_fputs (",aead", 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),
	openpgp_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 = openpgp_pk_algo_name (pk->revkey[i].algid);
	keyid_from_fingerprint (ctrl, pk->revkey[i].fpr,
	pk->revkey[i].fprlen, r_keyid);

	user = get_user_id_string_native (ctrl, r_keyid);
	tty_fprintf (fp,
	_("This key may be revoked by %s key %s"),
	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 is 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. */
	(void)i; /* Counting 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"));
	}
	}


	/* Print a warning if all encryption (sub\|primary)keys are expired.
	* The warning is not printed if there is no encryption
	* (sub\|primary)key at all. This function is called after the expire
	* data of the primary key has been changed. */
	void
	no_usable_encr_subkeys_warning (kbnode_t keyblock)
	{
	kbnode_t node;
	PKT_public_key *pk;
	int any_encr_key = 0;

	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;
	if ((pk->pubkey_usage & PUBKEY_USAGE_ENC))
	{
	any_encr_key = 1;
	if (pk->flags.valid && !pk->has_expired && !pk->flags.revoked
	&& !pk->flags.disabled)
	{
	return; /* Key is usable for encryption */
	}
	}
	}
	}

	if (any_encr_key && !opt.quiet)
	log_info (_("WARNING: No valid encryption subkey left over.\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\n", _("Such a user ID already exists on this key!"));
	}
	return 0;
	}

	err = make_keysig_packet (ctrl, &sig, pk, uid, NULL, pk, 0x13, 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;
	}


	/* Note: OPTIONS are from the EXPORT_* set. */
	static int
	menu_clean (ctrl_t ctrl, kbnode_t keyblock, unsigned int options)
	{
	KBNODE uidnode;
	int modified = 0;
	int 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, options,
	&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 ((options & EXPORT_MINIMAL)?
	_("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 && fprlen != 32)
	{
	log_error (_("cannot appoint a PGP 2.x style key as a "
	"designated revoker\n"));
	continue;
	}

	revkey.fprlen = fprlen;
	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_key_info (ctrl, NULL, 0, revoker_pk, 0);
	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,
	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;
	}


	/* Core function to add an ADSK to the KEYBLOCK. Returns 0 on success
	* or an error code. If SIGTIMESTAMP is not 0 it is used for the key
	* binding signature creation time; if not given the current time is
	* used. CACHE_NONCE can be used to avoid a second Pinetry pop-up for
	* appending the ADSK. */
	gpg_error_t
	append_adsk_to_key (ctrl_t ctrl, kbnode_t keyblock, PKT_public_key *adsk,
	u32 sigtimestamp, const char *cache_nonce)
	{
	gpg_error_t err;
	PKT_public_key main_pk; / The primary key. */
	PKT_signature *sig = NULL;
	kbnode_t adsknode = NULL;
	PACKET pkt; / (temp. use; will be put into a kbnode_t) */

	/* First get a copy. */
	adsk = copy_public_key_basics (NULL, adsk);

	/* Check compliance. */
	if (!gnupg_pk_is_compliant (opt.compliance, adsk->pubkey_algo, 0,
	adsk->pkey, nbits_from_pk (adsk), NULL))
	{
	char pkhex[MAX_FINGERPRINT_LEN*2+1];

	hexfingerprint (adsk, pkhex, sizeof pkhex);
	log_error (_("WARNING: key %s is not suitable for encryption"
	" in %s mode\n"),
	pkhex, gnupg_compliance_option_string (opt.compliance));
	err = gpg_error (GPG_ERR_FORBIDDEN);
	goto leave;
	}

	/* Get the primary key. */
	log_assert (keyblock->pkt->pkttype == PKT_PUBLIC_KEY);
	main_pk = keyblock->pkt->pkt.public_key;

	/* Prepare and append the adsk. */
	keyid_from_pk (main_pk, adsk->main_keyid); /* Fixup main keyid. */
	log_assert ((adsk->pubkey_usage & PUBKEY_USAGE_XENC_MASK));
	adsk->pubkey_usage = PUBKEY_USAGE_RENC; /* 'e' or 'r' -> 'r' */
	pkt = xtrycalloc (1, sizeof *pkt);
	if (!pkt)
	{
	err = gpg_error_from_syserror ();
	goto leave;
	}
	pkt->pkttype = PKT_PUBLIC_SUBKEY; /* Make sure it is a subkey. */
	pkt->pkt.public_key = adsk;
	adsknode = new_kbnode (pkt);

	/* Make the signature. */
	err = make_keysig_packet (ctrl, &sig, main_pk, NULL, adsk, main_pk, 0x18,
	sigtimestamp, 0,
	keygen_add_key_flags_and_expire, adsk, cache_nonce);
	adsk = NULL; /* (owned by adsknode - avoid double free.) */
	if (err)
	{
	write_status_error ("keysig", err);
	log_error ("creating key binding failed: %s\n", gpg_strerror (err));
	goto leave;
	}

	/* Append the subkey packet and the binding signature. */
	add_kbnode (keyblock, adsknode);
	adsknode = NULL;
	pkt = xtrycalloc (1, sizeof *pkt);
	if (!pkt)
	{
	err = gpg_error_from_syserror ();
	goto leave;
	}
	pkt->pkttype = PKT_SIGNATURE;
	pkt->pkt.signature = sig;
	add_kbnode (keyblock, new_kbnode (pkt));

	leave:
	release_kbnode (adsknode);
	free_public_key (adsk); /* Release our copy. */
	return err;
	}


	/*
	* Ask for a new additional decryption subkey and add it to the key
	* block. Returns true if the keyblock was changed and false
	* otherwise. If ADSKFPR is not NULL, this function has been called
	* by quick_addadsk and gives the fingerprint of the to be added key.
	*/
	static int
	menu_addadsk (ctrl_t ctrl, kbnode_t pub_keyblock, const char *adskfpr)
	{
	PKT_public_key *pk;
	PKT_public_key *adsk_pk = NULL;
	kbnode_t adsk_keyblock = NULL;
	char *answer = NULL;
	gpg_error_t err;
	KEYDB_SEARCH_DESC desc;
	byte fpr[MAX_FINGERPRINT_LEN];
	size_t fprlen;
	kbnode_t node;
	u32 sigtimestamp = make_timestamp ();

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

	for (;;)
	{
	xfree (answer);
	if (adskfpr)
	answer = xstrdup (adskfpr);
	else
	{
	answer = cpr_get_utf8
	("keyedit.addadsk",
	_("Enter the fingerprint of the additional decryption subkey: "));
	if (answer[0] == '\0' \|\| answer[0] == CONTROL_D)
	{
	err = gpg_error (GPG_ERR_CANCELED);
	goto leave;
	}
	}
	if (classify_user_id (answer, &desc, 1)
	\|\| desc.mode != KEYDB_SEARCH_MODE_FPR)
	{
	log_info (_("\"%s\" is not a fingerprint\n"), answer);
	err = gpg_error (GPG_ERR_INV_USER_ID);
	if (adskfpr)
	goto leave;
	continue;
	}

	/* Force searching for that exact fingerprint and for any key
	* which has a key with that fingerprint. */
	if (!strchr (answer, '!'))
	{
	char *tmpstr = xstrconcat (answer, "!", NULL);
	xfree (answer);
	answer = tmpstr;
	}

	free_public_key (adsk_pk);
	adsk_pk = xcalloc (1, sizeof *adsk_pk);
	adsk_pk->req_usage = PUBKEY_USAGE_ENC;
	release_kbnode (adsk_keyblock);
	adsk_keyblock = NULL;
	err = get_pubkey_byname (ctrl, GET_PUBKEY_NO_AKL,
	NULL, adsk_pk, answer, &adsk_keyblock, NULL, 1);
	if (err)
	{
	write_status_error ("add_adsk", err);
	log_info (_("key \"%s\" not found: %s\n"), answer,
	gpg_strerror (err));
	if ((!opt.batch \|\| adskfpr) && !opt.quiet
	&& gpg_err_code (err) == GPG_ERR_UNUSABLE_PUBKEY)
	log_info (_("Did you specify the fingerprint of a subkey?\n"));
	if (adskfpr)
	goto leave;
	continue;
	}

	for (node = adsk_keyblock; node; node = node->next)
	{
	if (node->pkt->pkttype == PKT_PUBLIC_KEY
	\|\| node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
	{
	pk = node->pkt->pkt.public_key;
	fingerprint_from_pk (pk, fpr, &fprlen);
	if (fprlen == desc.fprlen
	&& !memcmp (fpr, desc.u.fpr, fprlen)
	&& (pk->pubkey_usage & PUBKEY_USAGE_ENC))
	break;
	}
	}
	if (!node)
	{
	write_status_error ("add_adsk", err);
	err = gpg_error (GPG_ERR_WRONG_KEY_USAGE);
	log_info (_("key \"%s\" not found: %s\n"), answer,
	gpg_strerror (err));
	if ((!opt.batch \|\| adskfpr) && !opt.quiet)
	log_info (_("Did you specify the fingerprint of a subkey?\n"));
	if (adskfpr)
	goto leave;
	continue;
	}

	/* Check that the selected subkey is not yet on our keyblock. */
	err = has_key_with_fingerprint (pub_keyblock, desc.u.fpr, desc.fprlen);
	if (err)
	{
	log_info (_("key \"%s\" is already on this keyblock\n"), answer);
	if (adskfpr)
	goto leave;
	continue;
	}

	break;
	}

	/* Append the subkey. */
	log_assert (node->pkt->pkttype == PKT_PUBLIC_KEY
	\|\| node->pkt->pkttype == PKT_PUBLIC_SUBKEY);
	err = append_adsk_to_key (ctrl, pub_keyblock, node->pkt->pkt.public_key,
	sigtimestamp, NULL);


	leave:
	xfree (answer);
	free_public_key (adsk_pk);
	release_kbnode (adsk_keyblock);
	if (!err)
	return 1; /* The keyblock was modified. */
	else
	return 0; /* Not modified. */

	}


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

	(void)signumber;
	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, 1,
	SIGSUBPKT_PRIMARY_UID, NULL);
	if (!p)
	p = parse_sig_subpkt (sig, 0,
	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.
	* --quick-update-pred calls this with UNATTENDED set.
	*/
	static int
	menu_set_preferences (ctrl_t ctrl, kbnode_t pub_keyblock, int unattended)
	{
	PKT_public_key *main_pk;
	PKT_user_id *uid;
	KBNODE node;
	u32 keyid[2];
	int selected, select_all;
	int modified = 0;

	if (!unattended)
	no_primary_warning (pub_keyblock);

	select_all = unattended? 1 : !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"))
	{
	xfree (answer);
	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, 1, 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) ")))
	{
	xfree (user);
	continue;
	}
	}
	else if (uri == NULL)
	{
	/* There is no current keyserver URL, so there
	is no point in trying to un-set it. */
	xfree (user);
	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);
	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;
	}

	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 (ctrl, 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 (ctrl, 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,
	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 signature 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,
	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,
	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, 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/keygen.c b/g10/keygen.c
	index 1f4388f39..305604894 100644
	--- a/g10/keygen.c
	+++ b/g10/keygen.c
	@@ -1,7333 +1,7335 @@
	/* keygen.c - Generate a key pair
	* Copyright (C) 1998-2007, 2009-2011 Free Software Foundation, Inc.
	* Copyright (C) 2014, 2015, 2016, 2017, 2018 Werner Koch
	* Copyright (C) 2020, 2024 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 <errno.h>
	#include <sys/types.h>
	#include <sys/stat.h>
	#include <unistd.h>

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


	/* The default algorithms. If you change them, you should ensure the
	* value is inside the bounds enforced by ask_keysize and gen_xxx.
	* See also get_keysize_range which encodes the allowed ranges. The
	* default answer in ask_algo also needs to be adjusted. For Kyber
	* keep the values set in generate_subkeypair in sync. */
	#define DEFAULT_STD_KEY_PARAM "ed25519/cert,sign+cv25519/encr"
	#define FUTURE_STD_KEY_PARAM "ed25519/cert,sign+cv25519/encr"
	#define PQC_STD_KEY_PARAM_PRI "bp384/cert,sign"
	#define PQC_STD_KEY_PARAM_SUB "kyber768_bp256/encr"
	#define PQC_STD_KEY_PARAM PQC_STD_KEY_PARAM_PRI "+" PQC_STD_KEY_PARAM_SUB

	/* When generating keys using the streamlined key generation dialog,
	use this as a default expiration interval. */
	const char *default_expiration_interval = "3y";

	/* Flag bits used during key generation. */
	#define KEYGEN_FLAG_NO_PROTECTION 1
	#define KEYGEN_FLAG_TRANSIENT_KEY 2
	#define KEYGEN_FLAG_CREATE_V5_KEY 4

	/* Maximum number of supported algorithm preferences. */
	#define MAX_PREFS 30

	enum para_name {
	pKEYTYPE,
	pKEYLENGTH,
	pKEYCURVE,
	pKEYUSAGE,
	pSUBKEYTYPE,
	pSUBKEYLENGTH,
	pSUBKEYCURVE,
	pSUBKEYUSAGE,
	pAUTHKEYTYPE,
	pNAMEREAL,
	pNAMEEMAIL,
	pNAMECOMMENT,
	pPREFERENCES,
	pREVOKER,
	pUSERID,
	pCREATIONDATE,
	pKEYCREATIONDATE, /* Same in seconds since epoch. */
	pEXPIREDATE,
	pKEYEXPIRE, /* in n seconds */
	pSUBKEYCREATIONDATE,
	pSUBKEYEXPIREDATE,
	pSUBKEYEXPIRE, /* in n seconds */
	pAUTHKEYCREATIONDATE, /* Not yet used. */
	pPASSPHRASE,
	pSERIALNO,
	pCARDBACKUPKEY,
	pHANDLE,
	pKEYSERVER,
	pKEYGRIP,
	pSUBKEYGRIP,
	pADSK, /* this uses u.adsk */
	pVERSION, /* Desired version of the key packet. */
	pSUBVERSION, /* Ditto for the subpacket. */
	pCARDKEY /* The keygrips have been taken from active card (bool). */
	};

	struct para_data_s {
	struct para_data_s *next;
	int lnr;
	enum para_name key;
	union {
	u32 expire;
	u32 creation;
	int abool;
	unsigned int usage;
	struct revocation_key revkey;
	PKT_public_key adsk; / used with key == pADSK */
	char value[1];
	} u;
	};

	struct output_control_s
	{
	int lnr;
	int dryrun;
	unsigned int keygen_flags;
	int use_files;
	struct {
	char *fname;
	char *newfname;
	IOBUF stream;
	armor_filter_context_t *afx;
	} pub;
	};


	/* An object to help communicating with the actual key generation
	* code. */
	struct common_gen_cb_parm_s
	{
	/* This variable set to the result of agent_genkey. The callback
	* may take a copy of this so that the result can be used after we
	* are back from the deep key generation call stack. */
	gcry_sexp_t genkey_result;
	/* For a dual algorithms the result of the second algorithm
	* (e.g. Kyber). */
	gcry_sexp_t genkey_result2;
	};
	typedef struct common_gen_cb_parm_s *common_gen_cb_parm_t;


	/* A communication object to help adding certain notations to a key
	* binding signature. */
	struct opaque_data_usage_and_pk
	{
	unsigned int usage;
	const char *cpl_notation;
	PKT_public_key *pk;
	};


	/* FIXME: These globals vars are ugly. And using MAX_PREFS even for
	* aeads is useless, given that we don't expects more than a very few
	* algorithms. */
	static int prefs_initialized = 0;
	static byte sym_prefs[MAX_PREFS];
	static int nsym_prefs;
	static byte hash_prefs[MAX_PREFS];
	static int nhash_prefs;
	static byte zip_prefs[MAX_PREFS];
	static int nzip_prefs;
	static byte aead_prefs[MAX_PREFS];
	static int naead_prefs;
	static int mdc_available;
	static int ks_modify;
	static int aead_available;

	static void release_parameter_list (struct para_data_s *r);
	static struct para_data_s prepare_adsk (ctrl_t ctrl, const char name);
	static gpg_error_t parse_algo_usage_expire (ctrl_t ctrl, int for_subkey,
	const char algostr, const char usagestr,
	const char *expirestr,
	int r_algo, unsigned int r_usage,
	u32 r_expire, unsigned int r_nbits,
	const char *r_curve, int r_version,
	char *r_keygrip, u32 r_keytime);
	static void do_generate_keypair (ctrl_t ctrl, struct para_data_s *para,
	struct output_control_s *outctrl, int card );
	static int write_keyblock (iobuf_t out, kbnode_t node);
	static gpg_error_t gen_card_key (int keyno, int algo, int is_primary,
	kbnode_t pub_root, u32 *timestamp,
	u32 expireval, int *keygen_flags);
	static unsigned int get_keysize_range (int algo,
	unsigned int min, unsigned int max);
	static void do_add_notation (PKT_signature *sig,
	const char name, const char value,
	int critical);



	/* Return the algo string for a default new key. */
	const char *
	get_default_pubkey_algo (void)
	{
	if (opt.def_new_key_algo)
	{
	if (*opt.def_new_key_algo && !strchr (opt.def_new_key_algo, ':'))
	return opt.def_new_key_algo;
	/* To avoid checking that option every time we delay that until
	* here. The only thing we really need to make sure is that
	* there is no colon in the string so that the --gpgconf-list
	* command won't mess up its output. */
	log_info (_("invalid value for option '%s'\n"), "--default-new-key-algo");
	}
	return DEFAULT_STD_KEY_PARAM;
	}


	/* Depending on the USE some public key algorithms need to be changed.
	* In particular this is the case for standard EC curves which may
	* have either ECDSA or ECDH as their algo. The function returns the
	* new algo if demanded by USE. IF the function can't decide the algo
	* is returned as is and it is expected that a letter error check will
	* kick in. If no change is required ALGO is returned as is. */
	static int
	adjust_algo_for_ecdh_ecdsa (int algo, unsigned int use, const char *curve)
	{
	int needalgo;

	if (algo != PUBKEY_ALGO_ECDSA && algo != PUBKEY_ALGO_ECDH)
	return algo; /* Not an algo we need to adjust. */

	if (!curve \|\| !*curve)
	return algo; /* No curve given and thus we can't decide. */
	if (!openpgp_is_curve_supported (curve, &needalgo, NULL))
	return algo; /* Curve not supported - can't decide. */
	if (needalgo)
	return algo; /* No need to map the X{25519,488} curves because we
	* would also need to change the curve. */

	if (algo == PUBKEY_ALGO_ECDH
	&& (use & (PUBKEY_USAGE_SIG\|PUBKEY_USAGE_AUTH\|PUBKEY_USAGE_CERT)))
	return PUBKEY_ALGO_ECDSA; /* Switch to the signing variant. */

	if (algo == PUBKEY_ALGO_ECDSA
	&& (use & (PUBKEY_USAGE_ENC)))
	return PUBKEY_ALGO_ECDH; /* Switch to the encryption variant. */

	return algo; /* Return as is. */
	}


	static void
	print_status_key_created (int letter, PKT_public_key pk, const char handle)
	{
	byte array[MAX_FINGERPRINT_LEN], *s;
	char buf, p;
	size_t i, n;

	if (!handle)
	handle = "";

	buf = xmalloc (MAX_FINGERPRINT_LEN*2+31 + strlen (handle) + 1);

	p = buf;
	if (letter \|\| pk)
	{
	*p++ = letter;
	if (pk)
	{
	*p++ = ' ';
	fingerprint_from_pk (pk, array, &n);
	s = array;
	/* Fixme: Use bin2hex */
	for (i=0; i < n ; i++, s++, p += 2)
	snprintf (p, 3, "%02X", *s);
	}
	}
	if (*handle)
	{
	*p++ = ' ';
	for (i=0; handle[i] && i < 100; i++)
	*p++ = isspace ((unsigned int)handle[i])? '_':handle[i];
	}
	*p = 0;
	write_status_text ((letter \|\| pk)?STATUS_KEY_CREATED:STATUS_KEY_NOT_CREATED,
	buf);
	xfree (buf);
	}

	static void
	print_status_key_not_created (const char *handle)
	{
	print_status_key_created (0, NULL, handle);
	}



	static gpg_error_t
	write_uid (kbnode_t root, const char *s)
	{
	PACKET *pkt = NULL;
	size_t n = strlen (s);

	if (n > MAX_UID_PACKET_LENGTH - 10)
	return gpg_error (GPG_ERR_INV_USER_ID);

	pkt = xmalloc_clear (sizeof *pkt);
	pkt->pkttype = PKT_USER_ID;
	pkt->pkt.user_id = xmalloc_clear (sizeof *pkt->pkt.user_id + n);
	pkt->pkt.user_id->len = n;
	pkt->pkt.user_id->ref = 1;
	strcpy (pkt->pkt.user_id->name, s);
	add_kbnode (root, new_kbnode (pkt));
	return 0;
	}

	static void
	do_add_key_flags (PKT_signature *sig, unsigned int use)
	{
	byte buf[2] = { 0, 0 };

	/* The spec says that all primary keys MUST be able to certify. */
	if ( sig->sig_class != 0x18 )
	buf[0] \|= 0x01;

	if (use & PUBKEY_USAGE_SIG)
	buf[0] \|= 0x02;
	if (use & PUBKEY_USAGE_ENC)
	buf[0] \|= 0x04 \| 0x08;
	if (use & PUBKEY_USAGE_AUTH)
	buf[0] \|= 0x20;
	if (use & PUBKEY_USAGE_GROUP)
	buf[0] \|= 0x80;

	if (use & PUBKEY_USAGE_RENC)
	buf[1] \|= 0x04;
	if (use & PUBKEY_USAGE_TIME)
	buf[1] \|= 0x08;

	build_sig_subpkt (sig, SIGSUBPKT_KEY_FLAGS, buf, buf[1]? 2:1);
	}


	int
	keygen_add_key_expire (PKT_signature sig, void opaque)
	{
	PKT_public_key *pk = opaque;
	byte buf[8];
	u32 u;

	if (pk->expiredate)
	{
	if (pk->expiredate > pk->timestamp)
	u = pk->expiredate - pk->timestamp;
	else
	u = 1;

	buf[0] = (u >> 24) & 0xff;
	buf[1] = (u >> 16) & 0xff;
	buf[2] = (u >> 8) & 0xff;
	buf[3] = u & 0xff;
	build_sig_subpkt (sig, SIGSUBPKT_KEY_EXPIRE, buf, 4);
	}
	else
	{
	/* Make sure we don't leave a key expiration subpacket lying
	around */
	delete_sig_subpkt (sig->hashed, SIGSUBPKT_KEY_EXPIRE);
	}

	return 0;
	}


	/* Add the key usage (i.e. key flags) in SIG from the public keys
	* pubkey_usage field. OPAQUE has the public key. */
	int
	keygen_add_key_flags (PKT_signature sig, void opaque)
	{
	PKT_public_key *pk = opaque;

	do_add_key_flags (sig, pk->pubkey_usage);
	return 0;
	}


	int
	keygen_add_key_flags_and_expire (PKT_signature sig, void opaque)
	{
	keygen_add_key_flags (sig, opaque);
	return keygen_add_key_expire (sig, opaque);
	}


	/* This is only used to write the key binding signature. It is not
	* used for the primary key. */
	static int
	keygen_add_key_flags_from_oduap (PKT_signature sig, void opaque)
	{
	struct opaque_data_usage_and_pk *oduap = opaque;

	do_add_key_flags (sig, oduap->usage);
	if (oduap->cpl_notation)
	do_add_notation (sig, "cpl@gnupg.org", oduap->cpl_notation, 0);
	return keygen_add_key_expire (sig, oduap->pk);
	}


	static int
	set_one_pref (int val, int type, const char item, byte buf, int *nbuf)
	{
	int i;

	for (i=0; i < *nbuf; i++ )
	if (buf[i] == val)
	{
	log_info (_("preference '%s' duplicated\n"), item);
	return -1;
	}

	if (*nbuf >= MAX_PREFS)
	{
	if(type==1)
	log_info(_("too many cipher preferences\n"));
	else if(type==2)
	log_info(_("too many digest preferences\n"));
	else if(type==3)
	log_info(_("too many compression preferences\n"));
	else if(type==4)
	log_info(_("too many AEAD preferences\n"));
	else
	BUG();

	return -1;
	}

	buf[(*nbuf)++] = val;
	return 0;
	}

	/*
	* Parse the supplied string and use it to set the standard
	* preferences. The string may be in a form like the one printed by
	* "pref" (something like: "S10 S3 H3 H2 Z2 Z1") or the actual
	* cipher/hash/compress names. Use NULL to set the default
	* preferences. Returns: 0 = okay
	* PERSONAL is either 0 or one PREFTYPE_*
	*/
	int
	keygen_set_std_prefs (const char *string,int personal)
	{
	byte sym[MAX_PREFS], hash[MAX_PREFS], zip[MAX_PREFS], aead[MAX_PREFS];
	int nsym=0, nhash=0, nzip=0, naead=0, val, rc=0;
	int mdc=1, modify=0; /* mdc defaults on, modify defaults off. */
	char dummy_string[254+1]; / Enough for 25 items. */

	if (!string \|\| !ascii_strcasecmp (string, "default"))
	{
	if (opt.def_preference_list)
	string=opt.def_preference_list;
	else
	{
	int any_compress = 0;
	dummy_string[0]='\0';

	/* The rationale why we use the order AES256,192,128 is
	for compatibility reasons with PGP. If gpg would
	define AES128 first, we would get the somewhat
	confusing situation:

	gpg -r pgpkey -r gpgkey ---gives--> AES256
	gpg -r gpgkey -r pgpkey ---gives--> AES

	Note that by using --personal-cipher-preferences it is
	possible to prefer AES128.
	*/

	/* Make sure we do not add more than 15 items here, as we
	could overflow the size of dummy_string. We currently
	have at most 12. */
	if ( !openpgp_cipher_test_algo (CIPHER_ALGO_AES256) )
	strcat(dummy_string,"S9 ");
	if ( !openpgp_cipher_test_algo (CIPHER_ALGO_AES192) )
	strcat(dummy_string,"S8 ");
	if ( !openpgp_cipher_test_algo (CIPHER_ALGO_AES) )
	strcat(dummy_string,"S7 ");
	strcat(dummy_string,"S2 "); /* 3DES */

	if (!openpgp_aead_test_algo (AEAD_ALGO_OCB))
	strcat(dummy_string,"A2 ");

	if (personal)
	{
	/* The default internal hash algo order is:
	* SHA-256, SHA-384, SHA-512, SHA-224, SHA-1.
	*/
	if (!openpgp_md_test_algo (DIGEST_ALGO_SHA256))
	strcat (dummy_string, "H8 ");

	if (!openpgp_md_test_algo (DIGEST_ALGO_SHA384))
	strcat (dummy_string, "H9 ");

	if (!openpgp_md_test_algo (DIGEST_ALGO_SHA512))
	strcat (dummy_string, "H10 ");
	}
	else
	{
	/* The default advertised hash algo order is:
	* SHA-512, SHA-384, SHA-256, SHA-224, SHA-1.
	*/
	if (!openpgp_md_test_algo (DIGEST_ALGO_SHA512))
	strcat (dummy_string, "H10 ");

	if (!openpgp_md_test_algo (DIGEST_ALGO_SHA384))
	strcat (dummy_string, "H9 ");

	if (!openpgp_md_test_algo (DIGEST_ALGO_SHA256))
	strcat (dummy_string, "H8 ");
	}

	if (!openpgp_md_test_algo (DIGEST_ALGO_SHA224))
	strcat (dummy_string, "H11 ");

	strcat (dummy_string, "H2 "); /* SHA-1 */

	if(!check_compress_algo(COMPRESS_ALGO_ZLIB))
	{
	strcat(dummy_string,"Z2 ");
	any_compress = 1;
	}

	if(!check_compress_algo(COMPRESS_ALGO_BZIP2))
	{
	strcat(dummy_string,"Z3 ");
	any_compress = 1;
	}

	if(!check_compress_algo(COMPRESS_ALGO_ZIP))
	{
	strcat(dummy_string,"Z1 ");
	any_compress = 1;
	}

	/* In case we have no compress algo at all, declare that
	we prefer no compression. */
	if (!any_compress)
	strcat(dummy_string,"Z0 ");

	/* Remove the trailing space. */
	if (*dummy_string && dummy_string[strlen (dummy_string)-1] == ' ')
	dummy_string[strlen (dummy_string)-1] = 0;

	string=dummy_string;
	}
	}
	else if (!ascii_strcasecmp (string, "none"))
	string = "";

	if(strlen(string))
	{
	char *prefstringbuf;
	char tok, prefstring;

	/* We need a writable string. */
	prefstring = prefstringbuf = xstrdup (string);

	while((tok=strsep(&prefstring," ,")))
	{
	if (!*tok)
	;
	else if((val=string_to_cipher_algo (tok)))
	{
	if(set_one_pref(val,1,tok,sym,&nsym))
	rc=-1;
	}
	else if((val=string_to_digest_algo (tok)))
	{
	if(set_one_pref(val,2,tok,hash,&nhash))
	rc=-1;
	}
	else if((val=string_to_compress_algo(tok))>-1)
	{
	if(set_one_pref(val,3,tok,zip,&nzip))
	rc=-1;
	}
	else if ((val=string_to_aead_algo (tok)))
	{
	if (set_one_pref (val, 4, tok, aead, &naead))
	rc = -1;
	}
	else if (!ascii_strcasecmp(tok, "mdc")
	\|\| !ascii_strcasecmp(tok, "[mdc]"))
	mdc=1;
	else if (!ascii_strcasecmp(tok, "no-mdc")
	\|\| !ascii_strcasecmp(tok, "[no-mdc]"))
	mdc=0;
	else if (!ascii_strcasecmp(tok, "ks-modify")
	\|\| !ascii_strcasecmp(tok, "[ks-modify]"))
	modify=1;
	else if (!ascii_strcasecmp(tok,"no-ks-modify")
	\|\| !ascii_strcasecmp(tok,"[no-ks-modify]"))
	modify=0;
	else if (!ascii_strcasecmp(tok,"aead")
	\|\| !ascii_strcasecmp(tok,"[aead]"))
	{
	/* Ignore because this is set from the preferences but
	* shown in the in the preferences/features list. */
	}
	else
	{
	log_info (_("invalid item '%s' in preference string\n"),tok);
	rc=-1;
	}
	}

	xfree (prefstringbuf);
	}

	if(!rc)
	{
	if(personal)
	{
	if(personal==PREFTYPE_SYM)
	{
	xfree(opt.personal_cipher_prefs);

	if(nsym==0)
	opt.personal_cipher_prefs=NULL;
	else
	{
	int i;

	opt.personal_cipher_prefs=
	xmalloc(sizeof(prefitem_t )(nsym+1));

	for (i=0; i<nsym; i++)
	{
	opt.personal_cipher_prefs[i].type = PREFTYPE_SYM;
	opt.personal_cipher_prefs[i].value = sym[i];
	}

	opt.personal_cipher_prefs[i].type = PREFTYPE_NONE;
	opt.personal_cipher_prefs[i].value = 0;
	}
	}
	else if(personal==PREFTYPE_HASH)
	{
	xfree(opt.personal_digest_prefs);

	if(nhash==0)
	opt.personal_digest_prefs=NULL;
	else
	{
	int i;

	opt.personal_digest_prefs=
	xmalloc(sizeof(prefitem_t )(nhash+1));

	for (i=0; i<nhash; i++)
	{
	opt.personal_digest_prefs[i].type = PREFTYPE_HASH;
	opt.personal_digest_prefs[i].value = hash[i];
	}

	opt.personal_digest_prefs[i].type = PREFTYPE_NONE;
	opt.personal_digest_prefs[i].value = 0;
	}
	}
	else if(personal==PREFTYPE_ZIP)
	{
	xfree(opt.personal_compress_prefs);

	if(nzip==0)
	opt.personal_compress_prefs=NULL;
	else
	{
	int i;

	opt.personal_compress_prefs=
	xmalloc(sizeof(prefitem_t )(nzip+1));

	for (i=0; i<nzip; i++)
	{
	opt.personal_compress_prefs[i].type = PREFTYPE_ZIP;
	opt.personal_compress_prefs[i].value = zip[i];
	}

	opt.personal_compress_prefs[i].type = PREFTYPE_NONE;
	opt.personal_compress_prefs[i].value = 0;
	}
	}
	}
	else
	{
	memcpy (sym_prefs, sym, (nsym_prefs=nsym));
	memcpy (hash_prefs, hash, (nhash_prefs=nhash));
	memcpy (zip_prefs, zip, (nzip_prefs=nzip));
	memcpy (aead_prefs, aead, (naead_prefs=naead));
	mdc_available = mdc;
	aead_available = !!naead;
	ks_modify = modify;
	prefs_initialized = 1;
	}
	}

	return rc;
	}


	/* Return a fake user ID containing the preferences. Caller must
	free. */
	PKT_user_id *
	keygen_get_std_prefs(void)
	{
	int i,j=0;
	PKT_user_id *uid=xmalloc_clear(sizeof(PKT_user_id));

	if(!prefs_initialized)
	keygen_set_std_prefs(NULL,0);

	uid->ref=1;

	uid->prefs = xmalloc ((sizeof(prefitem_t )
	(nsym_prefs+naead_prefs+nhash_prefs+nzip_prefs+1)));

	for(i=0;i<nsym_prefs;i++,j++)
	{
	uid->prefs[j].type=PREFTYPE_SYM;
	uid->prefs[j].value=sym_prefs[i];
	}

	for (i=0; i < naead_prefs; i++, j++)
	{
	uid->prefs[j].type = PREFTYPE_AEAD;
	uid->prefs[j].value = aead_prefs[i];
	}

	for(i=0;i<nhash_prefs;i++,j++)
	{
	uid->prefs[j].type=PREFTYPE_HASH;
	uid->prefs[j].value=hash_prefs[i];
	}

	for(i=0;i<nzip_prefs;i++,j++)
	{
	uid->prefs[j].type=PREFTYPE_ZIP;
	uid->prefs[j].value=zip_prefs[i];
	}

	uid->prefs[j].type=PREFTYPE_NONE;
	uid->prefs[j].value=0;

	uid->flags.mdc = mdc_available;
	uid->flags.aead = aead_available;
	uid->flags.ks_modify = ks_modify;

	return uid;
	}

	static void
	add_feature_mdc (PKT_signature *sig,int enabled)
	{
	const byte *s;
	size_t n;
	int i;
	char *buf;

	s = parse_sig_subpkt (sig, 1, SIGSUBPKT_FEATURES, &n );
	/* Already set or cleared */
	if (s && n &&
	((enabled && (s[0] & 0x01)) \|\| (!enabled && !(s[0] & 0x01))))
	return;

	if (!s \|\| !n) { /* create a new one */
	n = 1;
	buf = xmalloc_clear (n);
	}
	else {
	buf = xmalloc (n);
	memcpy (buf, s, n);
	}

	if(enabled)
	buf[0] \|= 0x01; /* MDC feature */
	else
	buf[0] &= ~0x01;

	/* Are there any bits set? */
	for(i=0;i<n;i++)
	if(buf[i]!=0)
	break;

	if(i==n)
	delete_sig_subpkt (sig->hashed, SIGSUBPKT_FEATURES);
	else
	build_sig_subpkt (sig, SIGSUBPKT_FEATURES, buf, n);

	xfree (buf);
	}


	static void
	add_feature_aead (PKT_signature *sig, int enabled)
	{
	const byte *s;
	size_t n;
	int i;
	char *buf;

	s = parse_sig_subpkt (sig, 1, SIGSUBPKT_FEATURES, &n );
	if (s && n && ((enabled && (s[0] & 0x02)) \|\| (!enabled && !(s[0] & 0x02))))
	return; /* Already set or cleared */

	if (!s \|\| !n)
	{ /* Create a new one */
	n = 1;
	buf = xmalloc_clear (n);
	}
	else
	{
	buf = xmalloc (n);
	memcpy (buf, s, n);
	}

	if (enabled)
	buf[0] \|= 0x02; /* AEAD supported */
	else
	buf[0] &= ~0x02;

	/* Are there any bits set? */
	for (i=0; i < n; i++)
	if (buf[i])
	break;

	if (i == n)
	delete_sig_subpkt (sig->hashed, SIGSUBPKT_FEATURES);
	else
	build_sig_subpkt (sig, SIGSUBPKT_FEATURES, buf, n);

	xfree (buf);
	}


	static void
	add_feature_v5 (PKT_signature *sig, int enabled)
	{
	const byte *s;
	size_t n;
	int i;
	char *buf;

	s = parse_sig_subpkt (sig, 1, SIGSUBPKT_FEATURES, &n );
	if (s && n && ((enabled && (s[0] & 0x04)) \|\| (!enabled && !(s[0] & 0x04))))
	return; /* Already set or cleared */

	if (!s \|\| !n)
	{ /* Create a new one */
	n = 1;
	buf = xmalloc_clear (n);
	}
	else
	{
	buf = xmalloc (n);
	memcpy (buf, s, n);
	}

	if (enabled)
	buf[0] \|= 0x04; /* v5 key supported */
	else
	buf[0] &= ~0x04;

	/* Are there any bits set? */
	for (i=0; i < n; i++)
	if (buf[i])
	break;

	if (i == n)
	delete_sig_subpkt (sig->hashed, SIGSUBPKT_FEATURES);
	else
	build_sig_subpkt (sig, SIGSUBPKT_FEATURES, buf, n);

	xfree (buf);
	}


	static void
	add_keyserver_modify (PKT_signature *sig,int enabled)
	{
	const byte *s;
	size_t n;
	int i;
	char *buf;

	/* The keyserver modify flag is a negative flag (i.e. no-modify) */
	enabled=!enabled;

	s = parse_sig_subpkt (sig, 1, SIGSUBPKT_KS_FLAGS, &n );
	/* Already set or cleared */
	if (s && n &&
	((enabled && (s[0] & 0x80)) \|\| (!enabled && !(s[0] & 0x80))))
	return;

	if (!s \|\| !n) { /* create a new one */
	n = 1;
	buf = xmalloc_clear (n);
	}
	else {
	buf = xmalloc (n);
	memcpy (buf, s, n);
	}

	if(enabled)
	buf[0] \|= 0x80; /* no-modify flag */
	else
	buf[0] &= ~0x80;

	/* Are there any bits set? */
	for(i=0;i<n;i++)
	if(buf[i]!=0)
	break;

	if(i==n)
	delete_sig_subpkt (sig->hashed, SIGSUBPKT_KS_FLAGS);
	else
	build_sig_subpkt (sig, SIGSUBPKT_KS_FLAGS, buf, n);

	xfree (buf);
	}


	int
	keygen_upd_std_prefs (PKT_signature sig, void opaque)
	{
	(void)opaque;

	if (!prefs_initialized)
	keygen_set_std_prefs (NULL, 0);

	if (nsym_prefs)
	build_sig_subpkt (sig, SIGSUBPKT_PREF_SYM, sym_prefs, nsym_prefs);
	else
	{
	delete_sig_subpkt (sig->hashed, SIGSUBPKT_PREF_SYM);
	delete_sig_subpkt (sig->unhashed, SIGSUBPKT_PREF_SYM);
	}

	if (naead_prefs)
	build_sig_subpkt (sig, SIGSUBPKT_PREF_AEAD, aead_prefs, naead_prefs);
	else
	{
	delete_sig_subpkt (sig->hashed, SIGSUBPKT_PREF_AEAD);
	delete_sig_subpkt (sig->unhashed, SIGSUBPKT_PREF_AEAD);
	}

	if (nhash_prefs)
	build_sig_subpkt (sig, SIGSUBPKT_PREF_HASH, hash_prefs, nhash_prefs);
	else
	{
	delete_sig_subpkt (sig->hashed, SIGSUBPKT_PREF_HASH);
	delete_sig_subpkt (sig->unhashed, SIGSUBPKT_PREF_HASH);
	}

	if (nzip_prefs)
	build_sig_subpkt (sig, SIGSUBPKT_PREF_COMPR, zip_prefs, nzip_prefs);
	else
	{
	delete_sig_subpkt (sig->hashed, SIGSUBPKT_PREF_COMPR);
	delete_sig_subpkt (sig->unhashed, SIGSUBPKT_PREF_COMPR);
	}

	/* Make sure that the MDC feature flag is set if needed. */
	add_feature_mdc (sig,mdc_available);
	add_feature_aead (sig, aead_available);
	add_feature_v5 (sig, 1);
	add_keyserver_modify (sig,ks_modify);
	keygen_add_keyserver_url(sig,NULL);

	return 0;
	}


	/****************
	* Add preference to the self signature packet.
	* This is only called for packets with version > 3.
	*/
	int
	keygen_add_std_prefs (PKT_signature sig, void opaque)
	{
	PKT_public_key *pk = opaque;

	do_add_key_flags (sig, pk->pubkey_usage);
	keygen_add_key_expire (sig, opaque );
	keygen_upd_std_prefs (sig, opaque);
	keygen_add_keyserver_url (sig,NULL);

	return 0;
	}

	int
	keygen_add_keyserver_url(PKT_signature sig, void opaque)
	{
	const char *url=opaque;

	if(!url)
	url=opt.def_keyserver_url;

	if(url)
	build_sig_subpkt(sig,SIGSUBPKT_PREF_KS,url,strlen(url));
	else
	delete_sig_subpkt (sig->hashed,SIGSUBPKT_PREF_KS);

	return 0;
	}


	/* This function is used to add a notations to a signature. In
	* general the caller should have cleared exiting notations before
	* adding new ones. For example by calling:
	*
	* delete_sig_subpkt(sig->hashed,SIGSUBPKT_NOTATION);
	* delete_sig_subpkt(sig->unhashed,SIGSUBPKT_NOTATION);
	*
	* Only human readable notaions may be added. NAME and value are
	* expected to be UTF-* strings.
	*/
	static void
	do_add_notation (PKT_signature sig, const char name, const char *value,
	int critical)
	{
	unsigned char *buf;
	unsigned int n1,n2;

	n1 = strlen (name);
	n2 = strlen (value);

	buf = xmalloc (8 + n1 + n2);

	buf[0] = 0x80; /* human readable. */
	buf[1] = buf[2] = buf[3] = 0;
	buf[4] = n1 >> 8;
	buf[5] = n1;
	buf[6] = n2 >> 8;
	buf[7] = n2;
	memcpy (buf+8, name, n1);
	memcpy (buf+8+n1, value, n2);
	build_sig_subpkt (sig,
	(SIGSUBPKT_NOTATION\|(critical?SIGSUBPKT_FLAG_CRITICAL:0)),
	buf, 8+n1+n2 );
	xfree (buf);
	}


	int
	keygen_add_notations(PKT_signature sig,void opaque)
	{
	struct notation *notation;

	/* We always start clean */
	delete_sig_subpkt(sig->hashed,SIGSUBPKT_NOTATION);
	delete_sig_subpkt(sig->unhashed,SIGSUBPKT_NOTATION);
	sig->flags.notation=0;

	for(notation=opaque;notation;notation=notation->next)
	if(!notation->flags.ignore)
	{
	unsigned char *buf;
	unsigned int n1,n2;

	n1=strlen(notation->name);
	if(notation->altvalue)
	n2=strlen(notation->altvalue);
	else if(notation->bdat)
	n2=notation->blen;
	else
	n2=strlen(notation->value);

	buf = xmalloc( 8 + n1 + n2 );

	/* human readable or not */
	buf[0] = notation->bdat?0:0x80;
	buf[1] = buf[2] = buf[3] = 0;
	buf[4] = n1 >> 8;
	buf[5] = n1;
	buf[6] = n2 >> 8;
	buf[7] = n2;
	memcpy(buf+8, notation->name, n1 );
	if(notation->altvalue)
	memcpy(buf+8+n1, notation->altvalue, n2 );
	else if(notation->bdat)
	memcpy(buf+8+n1, notation->bdat, n2 );
	else
	memcpy(buf+8+n1, notation->value, n2 );
	build_sig_subpkt( sig, SIGSUBPKT_NOTATION \|
	(notation->flags.critical?SIGSUBPKT_FLAG_CRITICAL:0),
	buf, 8+n1+n2 );
	xfree(buf);
	}

	return 0;
	}


	int
	keygen_add_revkey (PKT_signature sig, void opaque)
	{
	struct revocation_key *revkey = opaque;
	byte buf[2+MAX_FINGERPRINT_LEN];

	log_assert (revkey->fprlen <= MAX_FINGERPRINT_LEN);
	buf[0] = revkey->class;
	buf[1] = revkey->algid;
	memcpy (buf + 2, revkey->fpr, revkey->fprlen);
	memset (buf + 2 + revkey->fprlen, 0, sizeof (revkey->fpr) - revkey->fprlen);

	build_sig_subpkt (sig, SIGSUBPKT_REV_KEY, buf, 2+revkey->fprlen);

	/* All sigs with revocation keys set are nonrevocable. */
	sig->flags.revocable = 0;
	buf[0] = 0;
	build_sig_subpkt (sig, SIGSUBPKT_REVOCABLE, buf, 1);

	parse_revkeys (sig);

	return 0;
	}



	/* Create a back-signature. If TIMESTAMP is not NULL, use it for the
	signature creation time. */
	gpg_error_t
	make_backsig (ctrl_t ctrl, PKT_signature sig, PKT_public_key pk,
	PKT_public_key sub_pk, PKT_public_key sub_psk,
	u32 timestamp, const char *cache_nonce)
	{
	gpg_error_t err;
	PKT_signature *backsig;

	cache_public_key (sub_pk);

	err = make_keysig_packet (ctrl, &backsig, pk, NULL, sub_pk, sub_psk, 0x19,
	timestamp, 0, NULL, NULL, cache_nonce);
	if (err)
	log_error ("make_keysig_packet failed for backsig: %s\n",
	gpg_strerror (err));
	else
	{
	/* Get it into a binary packed form. */
	IOBUF backsig_out = iobuf_temp();
	PACKET backsig_pkt;

	init_packet (&backsig_pkt);
	backsig_pkt.pkttype = PKT_SIGNATURE;
	backsig_pkt.pkt.signature = backsig;
	err = build_packet (backsig_out, &backsig_pkt);
	free_packet (&backsig_pkt, NULL);
	if (err)
	log_error ("build_packet failed for backsig: %s\n", gpg_strerror (err));
	else
	{
	size_t pktlen = 0;
	byte *buf = iobuf_get_temp_buffer (backsig_out);

	/* Remove the packet header. */
	if(buf[0]&0x40)
	{
	if (buf[1] < 192)
	{
	pktlen = buf[1];
	buf += 2;
	}
	else if(buf[1] < 224)
	{
	pktlen = (buf[1]-192)*256;
	pktlen += buf[2]+192;
	buf += 3;
	}
	else if (buf[1] == 255)
	{
	pktlen = buf32_to_size_t (buf+2);
	buf += 6;
	}
	else
	BUG ();
	}
	else
	{
	int mark = 1;

	switch (buf[0]&3)
	{
	case 3:
	BUG ();
	break;

	case 2:
	pktlen = (size_t)buf[mark++] << 24;
	pktlen \|= buf[mark++] << 16;
	/* fall through */
	case 1:
	pktlen \|= buf[mark++] << 8;
	/* fall through */
	case 0:
	pktlen \|= buf[mark++];
	}

	buf += mark;
	}

	/* Now make the binary blob into a subpacket. */
	build_sig_subpkt (sig, SIGSUBPKT_SIGNATURE, buf, pktlen);

	iobuf_close (backsig_out);
	}
	}

	return err;
	}


	/* This function should be called to make sure that
	* opt.def_new_key_adsks has no duplicates and that tehre is no '!'
	* suffix. We don't do this during normal option processing because
	* this list is only needed for a very few operations. Callingit
	* twice does not harm. Users of the option list should skip empty
	* items. */
	void
	keygen_prepare_new_key_adsks (void)
	{
	strlist_t sl, slr;
	char *p;

	for (sl = opt.def_new_key_adsks; sl; sl = sl->next)
	{
	if (!*sl->d)
	continue;
	p = strchr (sl->d, '!');
	if (p)
	*p = 0;
	for (slr = opt.def_new_key_adsks; slr != sl; slr = slr->next)
	if (!ascii_strcasecmp (sl->d, slr->d))
	{
	sl->d = 0; / clear fpr to mark this as a duplicate. */
	break;
	}
	}
	}


	/* Append all default ADSKs to the KEYBLOCK but ignore those which are
	* already on that keyblock. Returns 0 if any key has been added;
	* GPG_ERR_FALSE if no key was added or any other error code. */
	gpg_error_t
	append_all_default_adsks (ctrl_t ctrl, kbnode_t keyblock)
	{
	gpg_error_t err = 0;
	int any_done = 0;
	strlist_t sl;
	struct para_data_s *para;
	byte adskfpr[MAX_FINGERPRINT_LEN];
	size_t adskfprlen;
	u32 sigtimestamp = make_timestamp ();

	keygen_prepare_new_key_adsks ();
	for (sl = opt.def_new_key_adsks; sl && !err; sl = sl->next)
	{
	if (!*sl->d)
	continue;
	para = prepare_adsk (ctrl, sl->d);
	if (para)
	{
	fingerprint_from_pk (para->u.adsk, adskfpr, &adskfprlen);
	if (!has_key_with_fingerprint (keyblock, adskfpr, adskfprlen))
	{
	/* Fixme: We should use a cache nonce so that only one
	* pinentry pops up. */
	err = append_adsk_to_key (ctrl, keyblock, para->u.adsk,
	sigtimestamp, NULL);
	if (!err)
	any_done = 1;
	}
	release_parameter_list (para);
	}
	}

	if (!err && !any_done)
	err = gpg_error (GPG_ERR_FALSE);

	return err;
	}


	/* Write a direct key signature to the first key in ROOT using the key
	PSK. REVKEY is describes the direct key signature and TIMESTAMP is
	the timestamp to set on the signature. */
	static gpg_error_t
	write_direct_sig (ctrl_t ctrl, kbnode_t root, PKT_public_key *psk,
	struct revocation_key *revkey, u32 timestamp,
	const char *cache_nonce)
	{
	gpg_error_t err;
	PACKET *pkt;
	PKT_signature *sig;
	KBNODE node;
	PKT_public_key *pk;

	if (opt.verbose)
	log_info (_("writing direct signature\n"));

	/* Get the pk packet from the pub_tree. */
	node = find_kbnode (root, PKT_PUBLIC_KEY);
	if (!node)
	BUG ();
	pk = node->pkt->pkt.public_key;

	/* We have to cache the key, so that the verification of the
	signature creation is able to retrieve the public key. */
	cache_public_key (pk);

	/* Make the signature. */
	err = make_keysig_packet (ctrl, &sig, pk, NULL,NULL, psk, 0x1F,
	timestamp, 0,
	keygen_add_revkey, revkey, cache_nonce);
	if (err)
	{
	log_error ("make_keysig_packet failed: %s\n", gpg_strerror (err) );
	return err;
	}

	pkt = xmalloc_clear (sizeof *pkt);
	pkt->pkttype = PKT_SIGNATURE;
	pkt->pkt.signature = sig;
	add_kbnode (root, new_kbnode (pkt));
	return err;
	}



	/* Write a self-signature to the first user id in ROOT using the key
	PSK. USE and TIMESTAMP give the extra data we need for the
	signature. */
	static gpg_error_t
	write_selfsigs (ctrl_t ctrl, kbnode_t root, PKT_public_key *psk,
	unsigned int use, u32 timestamp, const char *cache_nonce)
	{
	gpg_error_t err;
	PACKET *pkt;
	PKT_signature *sig;
	PKT_user_id *uid;
	KBNODE node;
	PKT_public_key *pk;

	if (opt.verbose)
	log_info (_("writing self signature\n"));

	/* Get the uid packet from the list. */
	node = find_kbnode (root, PKT_USER_ID);
	if (!node)
	BUG(); /* No user id packet in tree. */
	uid = node->pkt->pkt.user_id;

	/* Get the pk packet from the pub_tree. */
	node = find_kbnode (root, PKT_PUBLIC_KEY);
	if (!node)
	BUG();
	pk = node->pkt->pkt.public_key;

	/* The usage has not yet been set - do it now. */
	pk->pubkey_usage = use;

	/* We have to cache the key, so that the verification of the
	signature creation is able to retrieve the public key. */
	cache_public_key (pk);

	/* Make the signature. */
	err = make_keysig_packet (ctrl, &sig, pk, uid, NULL, psk, 0x13,
	timestamp, 0,
	keygen_add_std_prefs, pk, cache_nonce);
	if (err)
	{
	log_error ("make_keysig_packet failed: %s\n", gpg_strerror (err));
	return err;
	}

	pkt = xmalloc_clear (sizeof *pkt);
	pkt->pkttype = PKT_SIGNATURE;
	pkt->pkt.signature = sig;
	add_kbnode (root, new_kbnode (pkt));

	return err;
	}


	/* Write the key binding signature. If TIMESTAMP is not NULL use the
	signature creation time. PRI_PSK is the key use for signing.
	SUB_PSK is a key used to create a back-signature; that one is only
	used if USE has the PUBKEY_USAGE_SIG capability. */
	static int
	write_keybinding (ctrl_t ctrl, kbnode_t root,
	PKT_public_key pri_psk, PKT_public_key sub_psk,
	unsigned int use, u32 timestamp, const char *cache_nonce)
	{
	gpg_error_t err;
	PACKET *pkt;
	PKT_signature *sig;
	KBNODE node;
	PKT_public_key pri_pk, sub_pk;
	struct opaque_data_usage_and_pk oduap;

	if (opt.verbose)
	log_info(_("writing key binding signature\n"));

	/* Get the primary pk packet from the tree. */
	node = find_kbnode (root, PKT_PUBLIC_KEY);
	if (!node)
	BUG();
	pri_pk = node->pkt->pkt.public_key;

	/* We have to cache the key, so that the verification of the
	* signature creation is able to retrieve the public key. */
	cache_public_key (pri_pk);

	/* Find the last subkey. */
	sub_pk = NULL;
	for (node = root; node; node = node->next )
	{
	if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
	sub_pk = node->pkt->pkt.public_key;
	}
	if (!sub_pk)
	BUG();

	/* Make the signature. */
	oduap.usage = use;
	if ((use & PUBKEY_USAGE_ENC)
	&& opt.compliance == CO_DE_VS
	/* The required libgcrypt 1.11 won't yet claim a compliant RNG. */
	&& gnupg_rng_is_compliant (CO_DE_VS))
	oduap.cpl_notation = "de-vs";
	else
	oduap.cpl_notation = NULL;
	oduap.pk = sub_pk;
	err = make_keysig_packet (ctrl, &sig, pri_pk, NULL, sub_pk, pri_psk, 0x18,
	timestamp, 0,
	keygen_add_key_flags_from_oduap, &oduap,
	cache_nonce);
	if (err)
	{
	log_error ("make_keysig_packet failed: %s\n", gpg_strerror (err));
	return err;
	}

	/* Make a backsig. */
	if (use & PUBKEY_USAGE_SIG)
	{
	err = make_backsig (ctrl,
	sig, pri_pk, sub_pk, sub_psk, timestamp, cache_nonce);
	if (err)
	return err;
	}

	pkt = xmalloc_clear ( sizeof *pkt );
	pkt->pkttype = PKT_SIGNATURE;
	pkt->pkt.signature = sig;
	add_kbnode (root, new_kbnode (pkt) );
	return err;
	}


	/* Returns true if SEXP specified the curve ED448 or X448. */
	static int
	curve_is_448 (gcry_sexp_t sexp)
	{
	gcry_sexp_t list, l2;
	char *curve;
	int result;

	list = gcry_sexp_find_token (sexp, "public-key", 0);
	if (!list)
	return 0; /* Not a public key. */
	l2 = gcry_sexp_cadr (list);
	gcry_sexp_release (list);
	list = l2;
	if (!list)
	return 0; /* Bad public key. */

	l2 = gcry_sexp_find_token (list, "curve", 0);
	gcry_sexp_release (list);
	if (!l2)
	return 0; /* No curve parameter. */
	curve = gcry_sexp_nth_string (l2, 1);
	gcry_sexp_release (l2);
	if (!curve)
	return 0; /* Bad curve parameter. */
	result = (!ascii_strcasecmp (curve, "X448")
	\|\| !ascii_strcasecmp (curve, "Ed448")
	\|\| !ascii_strcasecmp (curve, "cv448"));
	xfree (curve);
	return result;
	}


	/* Extract the parameters in OpenPGP format from SEXP and put them
	* into the caller provided ARRAY. SEXP2 is used to provide the
	* parameters for dual algorithm (e.g. Kyber). */
	static gpg_error_t
	ecckey_from_sexp (gcry_mpi_t *array, gcry_sexp_t sexp,
	gcry_sexp_t sexp2, int algo, int pkversion)
	{
	gpg_error_t err;
	gcry_sexp_t list, l2;
	char *curve = NULL;
	int i;
	const char *oidstr;
	unsigned int nbits;

	array[0] = NULL;
	array[1] = NULL;
	array[2] = NULL;

	list = gcry_sexp_find_token (sexp, "public-key", 0);
	if (!list)
	return gpg_error (GPG_ERR_INV_OBJ);
	l2 = gcry_sexp_cadr (list);
	gcry_sexp_release (list);
	list = l2;
	if (!list)
	return gpg_error (GPG_ERR_NO_OBJ);

	l2 = gcry_sexp_find_token (list, "curve", 0);
	if (!l2)
	{
	err = gpg_error (GPG_ERR_NO_OBJ);
	goto leave;
	}
	curve = gcry_sexp_nth_string (l2, 1);
	if (!curve)
	{
	err = gpg_error (GPG_ERR_NO_OBJ);
	goto leave;
	}
	gcry_sexp_release (l2);
	oidstr = openpgp_curve_to_oid (curve, &nbits, NULL, pkversion > 4);
	if (!oidstr)
	{
	/* That can't happen because we used one of the curves
	gpg_curve_to_oid knows about. */
	err = gpg_error (GPG_ERR_INV_OBJ);
	goto leave;
	}

	err = openpgp_oid_from_str (oidstr, &array[0]);
	if (err)
	goto leave;

	err = sexp_extract_param_sos (list, "q", &array[1]);
	if (err)
	goto leave;

	gcry_sexp_release (list);
	list = NULL;

	if (algo == PUBKEY_ALGO_KYBER)
	{
	if (!sexp2)
	{
	err = gpg_error (GPG_ERR_MISSING_VALUE);
	goto leave;
	}

	list = gcry_sexp_find_token (sexp2, "public-key", 0);
	if (!list)
	{
	err = gpg_error (GPG_ERR_INV_OBJ);
	goto leave;
	}
	l2 = gcry_sexp_cadr (list);
	gcry_sexp_release (list);
	list = l2;
	if (!list)
	{
	err = gpg_error (GPG_ERR_NO_OBJ);
	goto leave;
	}

	l2 = gcry_sexp_find_token (list, "p", 1);
	if (!l2)
	{
	err = gpg_error (GPG_ERR_NO_OBJ); /* required parameter not found */
	goto leave;
	}
	array[2] = gcry_sexp_nth_mpi (l2, 1, GCRYMPI_FMT_OPAQUE);
	gcry_sexp_release (l2);
	if (!array[2])
	{
	err = gpg_error (GPG_ERR_INV_OBJ); /* required parameter invalid */
	goto leave;
	}
	}
	else if (algo == PUBKEY_ALGO_ECDH)
	{
	array[2] = pk_ecdh_default_params (nbits);
	if (!array[2])
	{
	err = gpg_error_from_syserror ();
	goto leave;
	}
	}

	leave:
	xfree (curve);
	gcry_sexp_release (list);
	if (err)
	{
	for (i=0; i < 3; i++)
	{
	gcry_mpi_release (array[i]);
	array[i] = NULL;
	}
	}
	return err;
	}


	/* Extract key parameters from SEXP and store them in ARRAY. ELEMS is
	a string where each character denotes a parameter name. TOPNAME is
	the name of the top element above the elements. */
	static int
	key_from_sexp (gcry_mpi_t *array, gcry_sexp_t sexp,
	const char topname, const char elems)
	{
	gcry_sexp_t list, l2;
	const char *s;
	int i, idx;
	int rc = 0;

	list = gcry_sexp_find_token (sexp, topname, 0);
	if (!list)
	return gpg_error (GPG_ERR_INV_OBJ);
	l2 = gcry_sexp_cadr (list);
	gcry_sexp_release (list);
	list = l2;
	if (!list)
	return gpg_error (GPG_ERR_NO_OBJ);

	for (idx=0,s=elems; *s; s++, idx++)
	{
	l2 = gcry_sexp_find_token (list, s, 1);
	if (!l2)
	{
	rc = gpg_error (GPG_ERR_NO_OBJ); /* required parameter not found */
	goto leave;
	}
	array[idx] = gcry_sexp_nth_mpi (l2, 1, GCRYMPI_FMT_USG);
	gcry_sexp_release (l2);
	if (!array[idx])
	{
	rc = gpg_error (GPG_ERR_INV_OBJ); /* required parameter invalid */
	goto leave;
	}
	}
	gcry_sexp_release (list);

	leave:
	if (rc)
	{
	for (i=0; i<idx; i++)
	{
	gcry_mpi_release (array[i]);
	array[i] = NULL;
	}
	gcry_sexp_release (list);
	}
	return rc;
	}


	/* Create a keyblock using the given KEYGRIP. ALGO is the OpenPGP
	* algorithm of that keygrip. If CARDKEY is true the key is expected
	* to already live on the active card. */
	static int
	do_create_from_keygrip (ctrl_t ctrl, int algo,
	const char *hexkeygrip, int cardkey,
	kbnode_t pub_root, u32 timestamp, u32 expireval,
	int is_subkey, int *keygen_flags)
	{
	int err;
	PACKET *pkt;
	PKT_public_key *pk;
	gcry_sexp_t s_key;
	gcry_sexp_t s_key2 = NULL;
	const char *algoelem;
	char *hexkeygrip_buffer = NULL;
	char *hexkeygrip2 = NULL;

	if (hexkeygrip[0] == '&')
	hexkeygrip++;
	if (strchr (hexkeygrip, ','))
	{
	hexkeygrip_buffer = xtrystrdup (hexkeygrip);
	if (!hexkeygrip_buffer)
	return gpg_error_from_syserror ();
	hexkeygrip = hexkeygrip_buffer;
	hexkeygrip2 = strchr (hexkeygrip_buffer, ',');
	if (hexkeygrip2)
	*hexkeygrip2++ = 0;
	}


	switch (algo)
	{
	case PUBKEY_ALGO_RSA: algoelem = "ne"; break;
	case PUBKEY_ALGO_DSA: algoelem = "pqgy"; break;
	case PUBKEY_ALGO_ELGAMAL_E: algoelem = "pgy"; break;
	case PUBKEY_ALGO_ECDH:
	case PUBKEY_ALGO_ECDSA: algoelem = ""; break;
	case PUBKEY_ALGO_EDDSA: algoelem = ""; break;
	case PUBKEY_ALGO_KYBER: algoelem = ""; break;
	default:
	xfree (hexkeygrip_buffer);
	return gpg_error (GPG_ERR_INTERNAL);
	}

	/* Ask the agent for the public key matching HEXKEYGRIP. */
	if (cardkey)
	{
	err = agent_scd_readkey (ctrl, hexkeygrip, &s_key, NULL);
	if (err)
	{
	xfree (hexkeygrip_buffer);
	return err;
	}
	}
	else
	{
	unsigned char *public;

	err = agent_readkey (ctrl, 0, hexkeygrip, &public);
	if (err)
	{
	xfree (hexkeygrip_buffer);
	return err;
	}
	err = gcry_sexp_sscan (&s_key, NULL, public,
	gcry_sexp_canon_len (public, 0, NULL, NULL));
	xfree (public);
	if (err)
	{
	xfree (hexkeygrip_buffer);
	return err;
	}
	if (hexkeygrip2)
	{
	err = agent_readkey (ctrl, 0, hexkeygrip2, &public);
	if (err)
	{
	gcry_sexp_release (s_key);
	xfree (hexkeygrip_buffer);
	return err;
	}
	err = gcry_sexp_sscan (&s_key2, NULL, public,
	gcry_sexp_canon_len (public, 0, NULL, NULL));
	xfree (public);
	if (err)
	{
	gcry_sexp_release (s_key);
	xfree (hexkeygrip_buffer);
	return err;
	}
	}
	}

	/* For X448 and Kyber we force the use of v5 packets. */
	if (curve_is_448 (s_key) \|\| algo == PUBKEY_ALGO_KYBER)
	*keygen_flags \|= KEYGEN_FLAG_CREATE_V5_KEY;

	/* Build a public key packet. */
	pk = xtrycalloc (1, sizeof *pk);
	if (!pk)
	{
	err = gpg_error_from_syserror ();
	gcry_sexp_release (s_key);
	gcry_sexp_release (s_key2);
	xfree (hexkeygrip_buffer);
	return err;
	}

	pk->timestamp = timestamp;
	pk->version = (*keygen_flags & KEYGEN_FLAG_CREATE_V5_KEY)? 5 : 4;
	if (expireval)
	pk->expiredate = pk->timestamp + expireval;
	pk->pubkey_algo = algo;

	if (algo == PUBKEY_ALGO_KYBER)
	err = ecckey_from_sexp (pk->pkey, s_key, s_key2, algo, pk->version);
	else if (algo == PUBKEY_ALGO_ECDSA
	\|\| algo == PUBKEY_ALGO_EDDSA
	\|\| algo == PUBKEY_ALGO_ECDH )
	err = ecckey_from_sexp (pk->pkey, s_key, NULL, algo, pk->version);
	else
	err = key_from_sexp (pk->pkey, s_key, "public-key", algoelem);
	if (err)
	{
	log_error ("key_from_sexp failed: %s\n", gpg_strerror (err) );
	gcry_sexp_release (s_key);
	gcry_sexp_release (s_key2);
	free_public_key (pk);
	xfree (hexkeygrip_buffer);
	return err;
	}
	gcry_sexp_release (s_key);
	gcry_sexp_release (s_key2);

	pkt = xtrycalloc (1, sizeof *pkt);
	if (!pkt)
	{
	err = gpg_error_from_syserror ();
	free_public_key (pk);
	xfree (hexkeygrip_buffer);
	return err;
	}

	pkt->pkttype = is_subkey ? PKT_PUBLIC_SUBKEY : PKT_PUBLIC_KEY;
	pkt->pkt.public_key = pk;
	add_kbnode (pub_root, new_kbnode (pkt));

	xfree (hexkeygrip_buffer);
	return 0;
	}


	/* Common code for the key generation function gen_xxx. The optional
	* (COMMON_GEN_CB,COMMON_GEN_CB_PARM) can be used as communication
	* object. A KEYPARMS2 forces the use of a dual key (e.g. Kyber+ECC).
	*/
	static int
	common_gen (const char keyparms, const char keyparms2,
	int algo, const char *algoelem,
	kbnode_t pub_root, u32 timestamp, u32 expireval, int is_subkey,
	int keygen_flags, const char *passphrase,
	char cache_nonce_addr, char passwd_nonce_addr,
	gpg_error_t (*common_gen_cb)(common_gen_cb_parm_t),
	common_gen_cb_parm_t common_gen_cb_parm)
	{
	int err;
	PACKET *pkt;
	PKT_public_key *pk;
	gcry_sexp_t s_key;
	gcry_sexp_t s_key2 = NULL;

	err = agent_genkey (NULL, cache_nonce_addr, passwd_nonce_addr, keyparms,
	!!(keygen_flags & KEYGEN_FLAG_NO_PROTECTION),
	passphrase, timestamp,
	&s_key);
	if (err)
	{
	log_error ("agent_genkey failed: %s\n", gpg_strerror (err) );
	return err;
	}

	if (keyparms2)
	{
	unsigned char tmpgrip[KEYGRIP_LEN];
	char hexgrip1[2*KEYGRIP_LEN+1];
	char hexgrip2[2*KEYGRIP_LEN+1];

	err = agent_genkey (NULL, NULL, NULL, keyparms2,
	1 /* No protection */,
	NULL, timestamp,
	&s_key2);
	if (err)
	{
	log_error ("agent_genkey failed for second algo: %s\n",
	gpg_strerror (err) );
	gcry_sexp_release (s_key);
	return err;
	}

	if (!gcry_pk_get_keygrip (s_key, tmpgrip))
	{
	log_error ("error computing keygrip for generated key\n");
	gcry_sexp_release (s_key);
	gcry_sexp_release (s_key2);
	return gpg_error (GPG_ERR_GENERAL);
	}
	bin2hex (tmpgrip, KEYGRIP_LEN, hexgrip1);
	if (!gcry_pk_get_keygrip (s_key2, tmpgrip))
	{
	log_error ("error computing keygrip for generated key\n");
	gcry_sexp_release (s_key);
	gcry_sexp_release (s_key2);
	return gpg_error (GPG_ERR_GENERAL);
	}
	bin2hex (tmpgrip, KEYGRIP_LEN, hexgrip2);
	err = agent_crosslink_keys (NULL, hexgrip1, hexgrip2);
	if (err)
	{
	log_error ("error setting link attributes for generated keys\n");
	gcry_sexp_release (s_key);
	gcry_sexp_release (s_key2);
	return gpg_error (GPG_ERR_GENERAL);
	}
	}

	if (common_gen_cb && common_gen_cb_parm)
	{
	common_gen_cb_parm->genkey_result = s_key;
	common_gen_cb_parm->genkey_result2 = s_key2;
	err = common_gen_cb (common_gen_cb_parm);
	common_gen_cb_parm->genkey_result = NULL;
	common_gen_cb_parm->genkey_result2 = NULL;
	if (err)
	{
	gcry_sexp_release (s_key);
	gcry_sexp_release (s_key2);
	return err;
	}
	}

	pk = xtrycalloc (1, sizeof *pk);
	if (!pk)
	{
	err = gpg_error_from_syserror ();
	gcry_sexp_release (s_key);
	return err;
	}

	pk->timestamp = timestamp;
	pk->version = (keygen_flags & KEYGEN_FLAG_CREATE_V5_KEY)? 5 : 4;
	if (expireval)
	pk->expiredate = pk->timestamp + expireval;
	pk->pubkey_algo = algo;

	if (algo == PUBKEY_ALGO_KYBER)
	err = ecckey_from_sexp (pk->pkey, s_key, s_key2, algo, pk->version);
	else if (algo == PUBKEY_ALGO_ECDSA
	\|\| algo == PUBKEY_ALGO_EDDSA
	\|\| algo == PUBKEY_ALGO_ECDH )
	err = ecckey_from_sexp (pk->pkey, s_key, NULL, algo, pk->version);
	else
	err = key_from_sexp (pk->pkey, s_key, "public-key", algoelem);
	if (err)
	{
	log_error ("key_from_sexp failed: %s\n", gpg_strerror (err) );
	gcry_sexp_release (s_key);
	free_public_key (pk);
	return err;
	}
	gcry_sexp_release (s_key);
	gcry_sexp_release (s_key2);

	pkt = xtrycalloc (1, sizeof *pkt);
	if (!pkt)
	{
	err = gpg_error_from_syserror ();
	free_public_key (pk);
	return err;
	}

	pkt->pkttype = is_subkey ? PKT_PUBLIC_SUBKEY : PKT_PUBLIC_KEY;
	pkt->pkt.public_key = pk;
	add_kbnode (pub_root, new_kbnode (pkt));

	return 0;
	}


	/*
	* Generate an Elgamal key.
	*/
	static int
	gen_elg (int algo, unsigned int nbits, KBNODE pub_root,
	u32 timestamp, u32 expireval, int is_subkey,
	int keygen_flags, const char *passphrase,
	char cache_nonce_addr, char passwd_nonce_addr,
	gpg_error_t (*common_gen_cb)(common_gen_cb_parm_t),
	common_gen_cb_parm_t common_gen_cb_parm)
	{
	int err;
	char *keyparms;
	char nbitsstr[35];

	log_assert (is_ELGAMAL (algo));

	if (nbits < 1024)
	{
	nbits = 2048;
	log_info (_("keysize invalid; using %u bits\n"), nbits );
	}
	else if (nbits > 4096)
	{
	nbits = 4096;
	log_info (_("keysize invalid; using %u bits\n"), nbits );
	}

	if ((nbits % 32))
	{
	nbits = ((nbits + 31) / 32) * 32;
	log_info (_("keysize rounded up to %u bits\n"), nbits );
	}

	/* Note that we use transient-key only if no-protection has also
	been enabled. */
	snprintf (nbitsstr, sizeof nbitsstr, "%u", nbits);
	keyparms = xtryasprintf ("(genkey(%s(nbits %zu:%s)%s))",
	algo == GCRY_PK_ELG_E ? "openpgp-elg" :
	algo == GCRY_PK_ELG ? "elg" : "x-oops" ,
	strlen (nbitsstr), nbitsstr,
	((keygen_flags & KEYGEN_FLAG_TRANSIENT_KEY)
	&& (keygen_flags & KEYGEN_FLAG_NO_PROTECTION))?
	"(transient-key)" : "" );
	if (!keyparms)
	err = gpg_error_from_syserror ();
	else
	{
	err = common_gen (keyparms, NULL, algo, "pgy",
	pub_root, timestamp, expireval, is_subkey,
	keygen_flags, passphrase,
	cache_nonce_addr, passwd_nonce_addr,
	common_gen_cb, common_gen_cb_parm);
	xfree (keyparms);
	}

	return err;
	}


	/*
	* Generate an DSA key
	*/
	static gpg_error_t
	gen_dsa (unsigned int nbits, KBNODE pub_root,
	u32 timestamp, u32 expireval, int is_subkey,
	int keygen_flags, const char *passphrase,
	char cache_nonce_addr, char passwd_nonce_addr,
	gpg_error_t (*common_gen_cb)(common_gen_cb_parm_t),
	common_gen_cb_parm_t common_gen_cb_parm)
	{
	int err;
	unsigned int qbits;
	char *keyparms;
	char nbitsstr[35];
	char qbitsstr[35];

	if (nbits < 768)
	{
	nbits = 2048;
	log_info(_("keysize invalid; using %u bits\n"), nbits );
	}
	else if ( nbits > 3072 )
	{
	nbits = 3072;
	log_info(_("keysize invalid; using %u bits\n"), nbits );
	}

	if( (nbits % 64) )
	{
	nbits = ((nbits + 63) / 64) * 64;
	log_info(_("keysize rounded up to %u bits\n"), nbits );
	}

	/* To comply with FIPS rules we round up to the next value unless in
	expert mode. */
	if (!opt.expert && nbits > 1024 && (nbits % 1024))
	{
	nbits = ((nbits + 1023) / 1024) * 1024;
	log_info(_("keysize rounded up to %u bits\n"), nbits );
	}

	/*
	Figure out a q size based on the key size. FIPS 180-3 says:

	L = 1024, N = 160
	L = 2048, N = 224
	L = 2048, N = 256
	L = 3072, N = 256

	2048/256 is an odd pair since there is also a 2048/224 and
	3072/256. Matching sizes is not a very exact science.

	We'll do 256 qbits for nbits over 2047, 224 for nbits over 1024
	but less than 2048, and 160 for 1024 (DSA1).
	*/

	if (nbits > 2047)
	qbits = 256;
	else if ( nbits > 1024)
	qbits = 224;
	else
	qbits = 160;

	if (qbits != 160 )
	log_info (_("WARNING: some OpenPGP programs can't"
	" handle a DSA key with this digest size\n"));

	snprintf (nbitsstr, sizeof nbitsstr, "%u", nbits);
	snprintf (qbitsstr, sizeof qbitsstr, "%u", qbits);
	keyparms = xtryasprintf ("(genkey(dsa(nbits %zu:%s)(qbits %zu:%s)%s))",
	strlen (nbitsstr), nbitsstr,
	strlen (qbitsstr), qbitsstr,
	((keygen_flags & KEYGEN_FLAG_TRANSIENT_KEY)
	&& (keygen_flags & KEYGEN_FLAG_NO_PROTECTION))?
	"(transient-key)" : "" );
	if (!keyparms)
	err = gpg_error_from_syserror ();
	else
	{
	err = common_gen (keyparms, NULL, PUBKEY_ALGO_DSA, "pqgy",
	pub_root, timestamp, expireval, is_subkey,
	keygen_flags, passphrase,
	cache_nonce_addr, passwd_nonce_addr,
	common_gen_cb, common_gen_cb_parm);
	xfree (keyparms);
	}

	return err;
	}



	/*
	* Generate an ECC key.
	* Note that KEYGEN_FLAGS might be updated by this function to
	* indicate the forced creation of a v5 key.
	*/
	static gpg_error_t
	gen_ecc (int algo, const char *curve, kbnode_t pub_root,
	u32 timestamp, u32 expireval, int is_subkey,
	int keygen_flags, const char passphrase,
	char cache_nonce_addr, char passwd_nonce_addr,
	gpg_error_t (*common_gen_cb)(common_gen_cb_parm_t),
	common_gen_cb_parm_t common_gen_cb_parm)
	{
	gpg_error_t err;
	char *keyparms;

	log_assert (algo == PUBKEY_ALGO_ECDSA
	\|\| algo == PUBKEY_ALGO_EDDSA
	\|\| algo == PUBKEY_ALGO_ECDH);

	if (!curve \|\| !*curve)
	return gpg_error (GPG_ERR_UNKNOWN_CURVE);

	/* Map the displayed short forms of some curves to their canonical
	* names. */
	if (!ascii_strcasecmp (curve, "cv25519"))
	curve = "Curve25519";
	else if (!ascii_strcasecmp (curve, "ed25519"))
	curve = "Ed25519";
	else if (!ascii_strcasecmp (curve, "cv448"))
	curve = "X448";
	else if (!ascii_strcasecmp (curve, "ed448"))
	curve = "Ed448";

	/* Note that we use the "comp" flag with EdDSA to request the use of
	a 0x40 compression prefix octet. */
	if (algo == PUBKEY_ALGO_EDDSA && !strcmp (curve, "Ed25519"))
	{
	keyparms = xtryasprintf
	("(genkey(ecc(curve %zu:%s)(flags eddsa comp%s)))",
	strlen (curve), curve,
	(((*keygen_flags & KEYGEN_FLAG_TRANSIENT_KEY)
	&& (*keygen_flags & KEYGEN_FLAG_NO_PROTECTION))?
	" transient-key" : ""));
	}
	else if (algo == PUBKEY_ALGO_EDDSA && !strcmp (curve, "Ed448"))
	{
	*keygen_flags \|= KEYGEN_FLAG_CREATE_V5_KEY;
	keyparms = xtryasprintf
	("(genkey(ecc(curve %zu:%s)(flags comp%s)))",
	strlen (curve), curve,
	(((*keygen_flags & KEYGEN_FLAG_TRANSIENT_KEY)
	&& (*keygen_flags & KEYGEN_FLAG_NO_PROTECTION))?
	" transient-key" : ""));
	}
	else if (algo == PUBKEY_ALGO_ECDH && !strcmp (curve, "Curve25519"))
	{
	keyparms = xtryasprintf
	("(genkey(ecc(curve %zu:%s)(flags djb-tweak comp%s)))",
	strlen (curve), curve,
	(((*keygen_flags & KEYGEN_FLAG_TRANSIENT_KEY)
	&& (*keygen_flags & KEYGEN_FLAG_NO_PROTECTION))?
	" transient-key" : ""));
	}
	else if (algo == PUBKEY_ALGO_ECDH && !strcmp (curve, "X448"))
	{
	*keygen_flags \|= KEYGEN_FLAG_CREATE_V5_KEY;
	keyparms = xtryasprintf
	("(genkey(ecc(curve %zu:%s)(flags comp%s)))",
	strlen (curve), curve,
	(((*keygen_flags & KEYGEN_FLAG_TRANSIENT_KEY)
	&& (*keygen_flags & KEYGEN_FLAG_NO_PROTECTION))?
	" transient-key" : ""));
	}
	else
	{
	keyparms = xtryasprintf
	("(genkey(ecc(curve %zu:%s)(flags nocomp%s)))",
	strlen (curve), curve,
	(((*keygen_flags & KEYGEN_FLAG_TRANSIENT_KEY)
	&& (*keygen_flags & KEYGEN_FLAG_NO_PROTECTION))?
	" transient-key" : ""));
	}

	if (!keyparms)
	err = gpg_error_from_syserror ();
	else
	{
	err = common_gen (keyparms, NULL, algo, "",
	pub_root, timestamp, expireval, is_subkey,
	*keygen_flags, passphrase,
	cache_nonce_addr, passwd_nonce_addr,
	common_gen_cb, common_gen_cb_parm);
	xfree (keyparms);
	}

	return err;
	}


	/* Generate a dual ECC+Kyber key. Note that KEYGEN_FLAGS will be
	* updated by this function to indicate the forced creation of a v5
	* key. */
	static gpg_error_t
	gen_kyber (int algo, unsigned int nbits, const char *curve, kbnode_t pub_root,
	u32 timestamp, u32 expireval, int is_subkey,
	int keygen_flags, const char passphrase,
	char cache_nonce_addr, char passwd_nonce_addr,
	gpg_error_t (*common_gen_cb)(common_gen_cb_parm_t),
	common_gen_cb_parm_t common_gen_cb_parm)
	{
	gpg_error_t err;
	char *keyparms1;
	const char *keyparms2;

	log_assert (algo == PUBKEY_ALGO_KYBER);

	if (nbits == 768)
	keyparms2 = "(genkey(kyber768))";
	else if (nbits == 1024)
	keyparms2 = "(genkey(kyber1024))";
	else
	return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);

	if (!curve \|\| !*curve)
	return gpg_error (GPG_ERR_UNKNOWN_CURVE);

	*keygen_flags \|= KEYGEN_FLAG_CREATE_V5_KEY;

	if (!strcmp (curve, "Curve25519") \|\| !ascii_strcasecmp (curve, "cv25519"))
	{
	curve = "Curve25519";
	keyparms1 = xtryasprintf
	("(genkey(ecc(curve %zu:%s)(flags djb-tweak comp%s)))",
	strlen (curve), curve,
	(((*keygen_flags & KEYGEN_FLAG_TRANSIENT_KEY)
	&& (*keygen_flags & KEYGEN_FLAG_NO_PROTECTION))?
	" transient-key" : ""));
	}
	else if (!strcmp (curve, "X448") \|\| !ascii_strcasecmp (curve, "cv448"))
	{
	curve = "X448";
	keyparms1 = xtryasprintf
	("(genkey(ecc(curve %zu:%s)(flags comp%s)))",
	strlen (curve), curve,
	(((*keygen_flags & KEYGEN_FLAG_TRANSIENT_KEY)
	&& (*keygen_flags & KEYGEN_FLAG_NO_PROTECTION))?
	" transient-key" : ""));
	}
	else /* Should we use the compressed format? Check smartcard support. */
	{
	keyparms1 = xtryasprintf
	("(genkey(ecc(curve %zu:%s)(flags nocomp%s)))",
	strlen (curve), curve,
	(((*keygen_flags & KEYGEN_FLAG_TRANSIENT_KEY)
	&& (*keygen_flags & KEYGEN_FLAG_NO_PROTECTION))?
	" transient-key" : ""));
	}

	if (!keyparms1)
	err = gpg_error_from_syserror ();
	else
	{
	err = common_gen (keyparms1, keyparms2, algo, "",
	pub_root, timestamp, expireval, is_subkey,
	*keygen_flags, passphrase,
	cache_nonce_addr, passwd_nonce_addr,
	common_gen_cb, common_gen_cb_parm);
	xfree (keyparms1);
	}

	return err;
	}


	/*
	* Generate an RSA key.
	*/
	static int
	gen_rsa (int algo, unsigned int nbits, KBNODE pub_root,
	u32 timestamp, u32 expireval, int is_subkey,
	int keygen_flags, const char *passphrase,
	char cache_nonce_addr, char passwd_nonce_addr,
	gpg_error_t (*common_gen_cb)(common_gen_cb_parm_t),
	common_gen_cb_parm_t common_gen_cb_parm)
	{
	int err;
	char *keyparms;
	char nbitsstr[35];
	const unsigned maxsize = (opt.flags.large_rsa ? 8192 : 4096);

	log_assert (is_RSA(algo));

	if (!nbits)
	nbits = get_keysize_range (algo, NULL, NULL);

	if (nbits < 1024)
	{
	nbits = 3072;
	log_info (_("keysize invalid; using %u bits\n"), nbits );
	}
	else if (nbits > maxsize)
	{
	nbits = maxsize;
	log_info (_("keysize invalid; using %u bits\n"), nbits );
	}

	if ((nbits % 32))
	{
	nbits = ((nbits + 31) / 32) * 32;
	log_info (_("keysize rounded up to %u bits\n"), nbits );
	}

	snprintf (nbitsstr, sizeof nbitsstr, "%u", nbits);
	keyparms = xtryasprintf ("(genkey(rsa(nbits %zu:%s)%s))",
	strlen (nbitsstr), nbitsstr,
	((keygen_flags & KEYGEN_FLAG_TRANSIENT_KEY)
	&& (keygen_flags & KEYGEN_FLAG_NO_PROTECTION))?
	"(transient-key)" : "" );
	if (!keyparms)
	err = gpg_error_from_syserror ();
	else
	{
	err = common_gen (keyparms, NULL, algo, "ne",
	pub_root, timestamp, expireval, is_subkey,
	keygen_flags, passphrase,
	cache_nonce_addr, passwd_nonce_addr,
	common_gen_cb, common_gen_cb_parm);
	xfree (keyparms);
	}

	return err;
	}


	/****************
	* check valid days:
	* return 0 on error or the multiplier
	*/
	static int
	check_valid_days( const char *s )
	{
	if( !digitp(s) )
	return 0;
	for( s++; *s; s++)
	if( !digitp(s) )
	break;
	if( !*s )
	return 1;
	if( s[1] )
	return 0; /* e.g. "2323wc" */
	if( s == 'd' \|\| s == 'D' )
	return 1;
	if( s == 'w' \|\| s == 'W' )
	return 7;
	if( s == 'm' \|\| s == 'M' )
	return 30;
	if( s == 'y' \|\| s == 'Y' )
	return 365;
	return 0;
	}


	static void
	print_key_flags(int flags)
	{
	if(flags&PUBKEY_USAGE_SIG)
	tty_printf("%s ",_("Sign"));

	if(flags&PUBKEY_USAGE_CERT)
	tty_printf("%s ",_("Certify"));

	if(flags&PUBKEY_USAGE_ENC)
	tty_printf("%s ",_("Encrypt"));

	if(flags&PUBKEY_USAGE_AUTH)
	tty_printf("%s ",_("Authenticate"));

	if(flags&PUBKEY_USAGE_RENC)
	tty_printf("%s ", "RENC");
	}


	/* Ask for the key flags and return them. CURRENT gives the current
	* usage which should normally be given as 0. MASK gives the allowed
	* flags. */
	unsigned int
	ask_key_flags_with_mask (int algo, int subkey, unsigned int current,
	unsigned int mask)
	{
	/* TRANSLATORS: Please use only plain ASCII characters for the
	* translation. If this is not possible use single digits. The
	* string needs to 8 bytes long. Here is a description of the
	* functions:
	*
	* s = Toggle signing capability
	* e = Toggle encryption capability
	* a = Toggle authentication capability
	* q = Finish
	*/
	const char *togglers = _("SsEeAaQq");
	char *answer = NULL;
	const char *s;
	unsigned int possible;

	if ( strlen(togglers) != 8 )
	{
	tty_printf ("NOTE: Bad translation at %s:%d. "
	"Please report.\n", __FILE__, __LINE__);
	togglers = "11223300";
	}

	/* restrict the mask to the actual useful bits. */

	/* Mask the possible usage flags. This is for example used for a
	* card based key. For ECDH we need to allows additional usages if
	* they are provided. RENC is not directly poissible here but see
	* below for a workaround. */
	possible = (openpgp_pk_algo_usage (algo) & mask);
	possible &= ~PUBKEY_USAGE_RENC;
	possible &= ~PUBKEY_USAGE_GROUP;
	if (algo == PUBKEY_ALGO_ECDH)
	possible \|= (current & (PUBKEY_USAGE_ENC
	\|PUBKEY_USAGE_CERT
	\|PUBKEY_USAGE_SIG
	\|PUBKEY_USAGE_AUTH));

	/* However, only primary keys may certify. */
	if (subkey)
	possible &= ~PUBKEY_USAGE_CERT;

	/* Preload the current set with the possible set, without
	* authentication if CURRENT is 0. If CURRENT is non-zero we mask
	* with all possible usages. */
	if (current)
	current &= possible;
	else
	current = (possible&~PUBKEY_USAGE_AUTH);

	for (;;)
	{
	tty_printf("\n");
	tty_printf(_("Possible actions for this %s key: "),
	(algo == PUBKEY_ALGO_ECDH
	\|\| algo == PUBKEY_ALGO_ECDSA
	\|\| algo == PUBKEY_ALGO_EDDSA)
	? "ECC" : openpgp_pk_algo_name (algo));
	print_key_flags(possible);
	tty_printf("\n");
	tty_printf(_("Current allowed actions: "));
	print_key_flags(current);
	tty_printf("\n\n");

	if(possible&PUBKEY_USAGE_SIG)
	tty_printf(_(" (%c) Toggle the sign capability\n"),
	togglers[0]);
	if(possible&PUBKEY_USAGE_ENC)
	tty_printf(_(" (%c) Toggle the encrypt capability\n"),
	togglers[2]);
	if(possible&PUBKEY_USAGE_AUTH)
	tty_printf(_(" (%c) Toggle the authenticate capability\n"),
	togglers[4]);

	tty_printf(_(" (%c) Finished\n"),togglers[6]);
	tty_printf("\n");

	xfree(answer);
	answer = cpr_get("keygen.flags",_("Your selection? "));
	cpr_kill_prompt();

	if (*answer == '=')
	{
	/* Hack to allow direct entry of the capabilities. */
	current = 0;
	for (s=answer+1; *s; s++)
	{
	if ((s == 's' \|\| s == 'S') && (possible&PUBKEY_USAGE_SIG))
	current \|= PUBKEY_USAGE_SIG;
	else if ((s == 'e' \|\| s == 'E') && (possible&PUBKEY_USAGE_ENC))
	current \|= PUBKEY_USAGE_ENC;
	else if ((s == 'a' \|\| s == 'A') && (possible&PUBKEY_USAGE_AUTH))
	current \|= PUBKEY_USAGE_AUTH;
	else if (!subkey && *s == 'c')
	{
	/* Accept 'c' for the primary key because USAGE_CERT
	will be set anyway. This is for folks who
	want to experiment with a cert-only primary key. */
	current \|= PUBKEY_USAGE_CERT;
	}
	else if ((s == 'r' \|\| s == 'R') && (possible&PUBKEY_USAGE_ENC))
	{
	/* Allow to set RENC or an encryption capable key.
	* This is on purpose not shown in the menu. */
	current \|= PUBKEY_USAGE_RENC;
	}
	}
	break;
	}
	else if (strlen(answer)>1)
	tty_printf(_("Invalid selection.\n"));
	else if(answer=='\0' \|\| answer==togglers[6] \|\| *answer==togglers[7])
	break;
	else if((answer==togglers[0] \|\| answer==togglers[1])
	&& possible&PUBKEY_USAGE_SIG)
	{
	if(current&PUBKEY_USAGE_SIG)
	current&=~PUBKEY_USAGE_SIG;
	else
	current\|=PUBKEY_USAGE_SIG;
	}
	else if((answer==togglers[2] \|\| answer==togglers[3])
	&& possible&PUBKEY_USAGE_ENC)
	{
	if(current&PUBKEY_USAGE_ENC)
	current&=~PUBKEY_USAGE_ENC;
	else
	current\|=PUBKEY_USAGE_ENC;
	}
	else if((answer==togglers[4] \|\| answer==togglers[5])
	&& possible&PUBKEY_USAGE_AUTH)
	{
	if(current&PUBKEY_USAGE_AUTH)
	current&=~PUBKEY_USAGE_AUTH;
	else
	current\|=PUBKEY_USAGE_AUTH;
	}
	else
	tty_printf(_("Invalid selection.\n"));
	}

	xfree(answer);

	return current;
	}


	unsigned int
	ask_key_flags (int algo, int subkey, unsigned int current)
	{
	return ask_key_flags_with_mask (algo, subkey, current, ~0);
	}


	/* Check whether we have a key for the key with HEXGRIP. Returns 0 if
	there is no such key or the OpenPGP algo number for the key. */
	static int
	check_keygrip (ctrl_t ctrl, const char *hexgrip)
	{
	gpg_error_t err;
	unsigned char *public;
	size_t publiclen;
	int algo;

	if (hexgrip[0] == '&')
	hexgrip++;

	err = agent_readkey (ctrl, 0, hexgrip, &public);
	if (err)
	return 0;
	publiclen = gcry_sexp_canon_len (public, 0, NULL, NULL);

	algo = get_pk_algo_from_canon_sexp (public, publiclen);
	xfree (public);

	return map_gcry_pk_to_openpgp (algo);
	}



	/* Ask for an algorithm. The function returns the algorithm id to
	* create. If ADDMODE is false the function won't show an option to
	* create the primary and subkey combined and won't set R_USAGE
	* either. If a combined algorithm has been selected, the subkey
	* algorithm is stored at R_SUBKEY_ALGO. If R_KEYGRIP is given, the
	* user has the choice to enter the keygrip of an existing key. That
	* keygrip is then stored at this address. The caller needs to free
	* it. If R_CARDKEY is not NULL and the keygrip has been taken from
	* an active card, true is stored there; if R_KEYTIME is not NULL the
	* creation time of that key is then stored there. */
	static int
	ask_algo (ctrl_t ctrl, int addmode, int r_subkey_algo, unsigned int r_usage,
	char *r_keygrip, int r_cardkey, u32 *r_keytime)
	{
	gpg_error_t err;
	char *keygrip = NULL;
	u32 keytime = 0;
	char *answer = NULL;
	int cardkey = 0;
	int algo;
	int dummy_algo;

	if (!r_subkey_algo)
	r_subkey_algo = &dummy_algo;

	tty_printf (_("Please select what kind of key you want:\n"));

	#if GPG_USE_RSA
	if (!addmode)
	tty_printf (_(" (%d) RSA and RSA%s\n"), 1, "");
	#endif

	if (!addmode && opt.compliance != CO_DE_VS)
	tty_printf (_(" (%d) DSA and Elgamal%s\n"), 2, "");

	if (opt.compliance != CO_DE_VS)
	tty_printf (_(" (%d) DSA (sign only)%s\n"), 3, "");
	#if GPG_USE_RSA
	tty_printf (_(" (%d) RSA (sign only)%s\n"), 4, "");
	#endif

	if (addmode)
	{
	if (opt.compliance != CO_DE_VS)
	tty_printf (_(" (%d) Elgamal (encrypt only)%s\n"), 5, "");
	#if GPG_USE_RSA
	tty_printf (_(" (%d) RSA (encrypt only)%s\n"), 6, "");
	#endif
	}
	if (opt.expert)
	{
	if (opt.compliance != CO_DE_VS)
	tty_printf (_(" (%d) DSA (set your own capabilities)%s\n"), 7, "");
	#if GPG_USE_RSA
	tty_printf (_(" (%d) RSA (set your own capabilities)%s\n"), 8, "");
	#endif
	}

	#if GPG_USE_ECDSA \|\| GPG_USE_ECDH \|\| GPG_USE_EDDSA
	if (!addmode)
	tty_printf (_(" (%d) ECC (sign and encrypt)%s\n"), 9, _(" default") );
	tty_printf (_(" (%d) ECC (sign only)\n"), 10 );
	if (opt.expert)
	tty_printf (_(" (%d) ECC (set your own capabilities)%s\n"), 11, "");
	if (addmode)
	tty_printf (_(" (%d) ECC (encrypt only)%s\n"), 12, "");
	#endif

	if (opt.expert && r_keygrip)
	tty_printf (_(" (%d) Existing key%s\n"), 13, "");
	if (r_keygrip)
	tty_printf (_(" (%d) Existing key from card%s\n"), 14, "");

	/* Reserve 15 for Dilithium primary + Kyber subkey. */
	if (!addmode)
	tty_printf (_(" (%d) ECC and Kyber%s\n"), 16, "");
	if (addmode)
	tty_printf (_(" (%d) Kyber (encrypt only)%s\n"), 17, "");

	for (;;)
	{
	*r_usage = 0;
	*r_subkey_algo = 0;
	xfree (answer);
	answer = cpr_get ("keygen.algo", _("Your selection? "));
	cpr_kill_prompt ();
	algo = answer? atoi (answer) : 9; / Default algo is 9 */

	if (opt.compliance == CO_DE_VS
	&& (algo == 2 \|\| algo == 3 \|\| algo == 5 \|\| algo == 7))
	{
	tty_printf (_("Invalid selection.\n"));
	}
	else if ((algo == 1 \|\| !strcmp (answer, "rsa+rsa")) && !addmode)
	{
	algo = PUBKEY_ALGO_RSA;
	*r_subkey_algo = PUBKEY_ALGO_RSA;
	break;
	}
	else if ((algo == 2 \|\| !strcmp (answer, "dsa+elg")) && !addmode)
	{
	algo = PUBKEY_ALGO_DSA;
	*r_subkey_algo = PUBKEY_ALGO_ELGAMAL_E;
	break;
	}
	else if (algo == 3 \|\| !strcmp (answer, "dsa"))
	{
	algo = PUBKEY_ALGO_DSA;
	*r_usage = PUBKEY_USAGE_SIG;
	break;
	}
	else if (algo == 4 \|\| !strcmp (answer, "rsa/s"))
	{
	algo = PUBKEY_ALGO_RSA;
	*r_usage = PUBKEY_USAGE_SIG;
	break;
	}
	else if ((algo == 5 \|\| !strcmp (answer, "elg")) && addmode)
	{
	algo = PUBKEY_ALGO_ELGAMAL_E;
	*r_usage = PUBKEY_USAGE_ENC;
	break;
	}
	else if ((algo == 6 \|\| !strcmp (answer, "rsa/e")) && addmode)
	{
	algo = PUBKEY_ALGO_RSA;
	*r_usage = PUBKEY_USAGE_ENC;
	break;
	}
	else if ((algo == 7 \|\| !strcmp (answer, "dsa/*")) && opt.expert)
	{
	algo = PUBKEY_ALGO_DSA;
	*r_usage = ask_key_flags (algo, addmode, 0);
	break;
	}
	else if ((algo == 8 \|\| !strcmp (answer, "rsa/*")) && opt.expert)
	{
	algo = PUBKEY_ALGO_RSA;
	*r_usage = ask_key_flags (algo, addmode, 0);
	break;
	}
	else if ((algo == 9 \|\| !strcmp (answer, "ecc+ecc"))
	&& !addmode)
	{
	algo = PUBKEY_ALGO_ECDSA;
	*r_subkey_algo = PUBKEY_ALGO_ECDH;
	break;
	}
	else if ((algo == 10 \|\| !strcmp (answer, "ecc/s")))
	{
	algo = PUBKEY_ALGO_ECDSA;
	*r_usage = PUBKEY_USAGE_SIG;
	break;
	}
	else if ((algo == 11 \|\| !strcmp (answer, "ecc/*")) && opt.expert)
	{
	algo = PUBKEY_ALGO_ECDSA;
	*r_usage = ask_key_flags (algo, addmode, 0);
	break;
	}
	else if ((algo == 12 \|\| !strcmp (answer, "ecc/e"))
	&& addmode)
	{
	algo = PUBKEY_ALGO_ECDH;
	*r_usage = PUBKEY_USAGE_ENC;
	break;
	}
	else if ((algo == 13 \|\| !strcmp (answer, "keygrip"))
	&& opt.expert && r_keygrip)
	{
	for (;;)
	{
	xfree (answer);
	answer = cpr_get ("keygen.keygrip", _("Enter the keygrip: "));
	cpr_kill_prompt ();
	trim_spaces (answer);
	if (!*answer)
	{
	xfree (answer);
	answer = NULL;
	continue;
	}

	if (strlen (answer) == 40+1+40 && answer[40]==',')
	{
	int algo1, algo2;

	answer[40] = 0;
	algo1 = check_keygrip (ctrl, answer);
	algo2 = check_keygrip (ctrl, answer+41);
	answer[40] = ',';
	if (algo1 == PUBKEY_ALGO_ECDH && algo2 == PUBKEY_ALGO_KYBER)
	{
	algo = PUBKEY_ALGO_KYBER;
	break;
	}
	else if (!algo1 \|\| !algo2)
	tty_printf (_("No key with this keygrip\n"));
	else
	tty_printf ("Invalid combination for dual algo (%d,%d)\n",
	algo1, algo2);
	}
	else if (strlen (answer) != 40 &&
	!(answer[0] == '&' && strlen (answer+1) == 40))
	tty_printf
	(_("Not a valid keygrip (expecting 40 hex digits)\n"));
	else if (!(algo = check_keygrip (ctrl, answer)) )
	tty_printf (_("No key with this keygrip\n"));
	else
	break; /* Okay. */
	}
	xfree (keygrip);
	keygrip = answer;
	answer = NULL;
	*r_usage = ask_key_flags (algo, addmode, 0);
	break;
	}
	else if ((algo == 14 \|\| !strcmp (answer, "cardkey")) && r_keygrip)
	{
	char *serialno;
	keypair_info_t keypairlist, kpi;
	int count, selection;

	err = agent_scd_serialno (&serialno, NULL);
	if (err)
	{
	tty_printf (_("error reading the card: %s\n"),
	gpg_strerror (err));
	goto ask_again;
	}
	tty_printf (_("Serial number of the card: %s\n"), serialno);
	xfree (serialno);

	err = agent_scd_keypairinfo (ctrl, NULL, &keypairlist);
	if (err)
	{
	tty_printf (_("error reading the card: %s\n"),
	gpg_strerror (err));
	goto ask_again;
	}

	do
	{
	char authkeyref, encrkeyref, *signkeyref;

	agent_scd_getattr_one ("$AUTHKEYID", &authkeyref);
	agent_scd_getattr_one ("$ENCRKEYID", &encrkeyref);
	agent_scd_getattr_one ("$SIGNKEYID", &signkeyref);

	tty_printf (_("Available keys:\n"));
	for (count=1, kpi=keypairlist; kpi; kpi = kpi->next, count++)
	{
	gcry_sexp_t s_pkey;
	char *algostr = NULL;
	enum gcry_pk_algos algoid = 0;
	const char *keyref = kpi->idstr;
	int any = 0;

	if (!keyref)
	continue;

	if (agent_scd_readkey (ctrl, keyref, &s_pkey, NULL))
	continue;

	algostr = pubkey_algo_string (s_pkey, &algoid);
	gcry_sexp_release (s_pkey);

	/* We need to tweak the algo in case GCRY_PK_ECC is
	* returned because pubkey_algo_string is not aware
	* of the OpenPGP algo mapping. We need to
	* distinguish between ECDH and ECDSA but we can do
	* that only if we got usage flags.
	* Note: Keep this in sync with parse_key_parameter_part.
	*/
	if (algoid == GCRY_PK_ECC && algostr)
	{
	if (!strcmp (algostr, "ed25519"))
	kpi->algo = PUBKEY_ALGO_EDDSA;
	else if (!strcmp (algostr, "ed448"))
	kpi->algo = PUBKEY_ALGO_EDDSA;
	else if (!strcmp (algostr, "cv25519"))
	kpi->algo = PUBKEY_ALGO_ECDH;
	else if (!strcmp (algostr, "cv448"))
	kpi->algo = PUBKEY_ALGO_ECDH;
	else if ((kpi->usage & GCRY_PK_USAGE_ENCR))
	kpi->algo = PUBKEY_ALGO_ECDH;
	else
	kpi->algo = PUBKEY_ALGO_ECDSA;
	}
	else
	kpi->algo = map_gcry_pk_to_openpgp (algoid);

	tty_printf (" (%d) %s %s %s",
	count, kpi->keygrip, keyref, algostr);
	if ((kpi->usage & GCRY_PK_USAGE_CERT))
	{
	tty_printf ("%scert", any?",":" (");
	any = 1;
	}
	if ((kpi->usage & GCRY_PK_USAGE_SIGN))
	{
	tty_printf ("%ssign%s", any?",":" (",
	(signkeyref && keyref
	&& !strcmp (signkeyref, keyref))? "*":"");
	any = 1;
	}
	if ((kpi->usage & GCRY_PK_USAGE_AUTH))
	{
	tty_printf ("%sauth%s", any?",":" (",
	(authkeyref && keyref
	&& !strcmp (authkeyref, keyref))? "*":"");
	any = 1;
	}
	if ((kpi->usage & GCRY_PK_USAGE_ENCR))
	{
	tty_printf ("%sencr%s", any?",":" (",
	(encrkeyref && keyref
	&& !strcmp (encrkeyref, keyref))? "*":"");
	any = 1;
	}
	tty_printf ("%s\n", any?")":"");
	xfree (algostr);
	}

	xfree (answer);
	answer = cpr_get ("keygen.cardkey", _("Your selection? "));
	cpr_kill_prompt ();
	trim_spaces (answer);
	selection = atoi (answer);
	xfree (authkeyref);
	xfree (encrkeyref);
	xfree (signkeyref);
	}
	while (!(selection > 0 && selection < count));

	for (count=1,kpi=keypairlist; kpi; kpi = kpi->next, count++)
	if (count == selection)
	break;
	if (!kpi \|\| !kpi->algo)
	{
	/* Just in case no good key. */
	free_keypair_info (keypairlist);
	goto ask_again;
	}

	xfree (keygrip);
	keygrip = xstrdup (kpi->keygrip);
	cardkey = 1;
	algo = kpi->algo;
	keytime = kpi->keytime;

	/* In expert mode allow to change the usage flags. */
	if (opt.expert)
	*r_usage = ask_key_flags_with_mask (algo, addmode,
	kpi->usage, kpi->usage);
	else
	{
	*r_usage = kpi->usage;
	if (addmode)
	*r_usage &= ~GCRY_PK_USAGE_CERT;
	}
	free_keypair_info (keypairlist);
	break;
	}
	else if ((algo == 16 \|\| !strcmp (answer, "ecc+kyber")) && !addmode)
	{
	algo = PUBKEY_ALGO_ECDSA;
	*r_subkey_algo = PUBKEY_ALGO_KYBER;
	break;
	}
	else if ((algo == 17 \|\| !strcmp (answer, "kyber")) && addmode)
	{
	algo = PUBKEY_ALGO_KYBER;
	*r_usage = PUBKEY_USAGE_ENC;
	break;
	}
	else
	tty_printf (_("Invalid selection.\n"));

	ask_again:
	;
	}

	xfree(answer);
	if (r_keygrip)
	*r_keygrip = keygrip;
	if (r_cardkey)
	*r_cardkey = cardkey;
	if (r_keytime)
	*r_keytime = keytime;
	return algo;
	}


	static unsigned int
	get_keysize_range (int algo, unsigned int min, unsigned int max)
	{
	unsigned int def;
	unsigned int dummy1, dummy2;

	if (!min)
	min = &dummy1;
	if (!max)
	max = &dummy2;

	switch(algo)
	{
	case PUBKEY_ALGO_DSA:
	*min = opt.expert? 768 : 1024;
	*max=3072;
	def=2048;
	break;

	case PUBKEY_ALGO_ECDSA:
	case PUBKEY_ALGO_ECDH:
	*min=256;
	*max=521;
	def=256;
	break;

	case PUBKEY_ALGO_EDDSA:
	*min=255;
	*max=441;
	def=255;
	break;

	case PUBKEY_ALGO_KYBER:
	*min = 768;
	*max = 1024;
	def = 768;
	break;

	default:
	*min = opt.compliance == CO_DE_VS ? 2048: 1024;
	*max = 4096;
	def = 3072;
	break;
	}

	return def;
	}


	/* Return a fixed up keysize depending on ALGO. */
	static unsigned int
	fixup_keysize (unsigned int nbits, int algo, int silent)
	{
	unsigned int orig_nbits = nbits;

	if (algo == PUBKEY_ALGO_DSA && (nbits % 64))
	{
	nbits = ((nbits + 63) / 64) * 64;
	}
	else if (algo == PUBKEY_ALGO_EDDSA)
	{
	if (nbits < 256)
	nbits = 255;
	else
	nbits = 441;
	}
	else if (algo == PUBKEY_ALGO_ECDH \|\| algo == PUBKEY_ALGO_ECDSA)
	{
	if (nbits < 256)
	nbits = 256;
	else if (nbits < 384)
	nbits = 384;
	else
	nbits = 521;
	}
	else if (algo == PUBKEY_ALGO_KYBER)
	{
	/* (in reality the numbers are not bits) */
	if (nbits < 768)
	nbits = 768;
	else if (nbits > 1024)
	nbits = 1024;
	}
	else if ((nbits % 32))
	{
	nbits = ((nbits + 31) / 32) * 32;
	}

	if (!silent && orig_nbits != nbits)
	tty_printf (_("rounded to %u bits\n"), nbits);

	return nbits;
	}


	/* Ask for the key size. ALGO is the algorithm. If PRIMARY_KEYSIZE
	is not 0, the function asks for the size of the encryption
	subkey. */
	static unsigned
	ask_keysize (int algo, unsigned int primary_keysize)
	{
	unsigned int nbits;
	unsigned int min, def, max;
	int for_subkey = !!primary_keysize;
	int autocomp = 0;

	def = get_keysize_range (algo, &min, &max);

	if (primary_keysize && !opt.expert)
	{
	/* Deduce the subkey size from the primary key size. */
	if (algo == PUBKEY_ALGO_DSA && primary_keysize > 3072)
	nbits = 3072; /* For performance reasons we don't support more
	than 3072 bit DSA. However we won't see this
	case anyway because DSA can't be used as an
	encryption subkey ;-). */
	else
	nbits = primary_keysize;
	autocomp = 1;
	goto leave;
	}

	tty_printf(_("%s keys may be between %u and %u bits long.\n"),
	openpgp_pk_algo_name (algo), min, max);

	for (;;)
	{
	char prompt, answer;

	if (for_subkey)
	prompt = xasprintf (_("What keysize do you want "
	"for the subkey? (%u) "), def);
	else
	prompt = xasprintf (_("What keysize do you want? (%u) "), def);
	answer = cpr_get ("keygen.size", prompt);
	cpr_kill_prompt ();
	nbits = *answer? atoi (answer): def;
	xfree(prompt);
	xfree(answer);

	if(nbits<min \|\| nbits>max)
	tty_printf(_("%s keysizes must be in the range %u-%u\n"),
	openpgp_pk_algo_name (algo), min, max);
	else
	break;
	}

	tty_printf (_("Requested keysize is %u bits\n"), nbits);

	leave:
	nbits = fixup_keysize (nbits, algo, autocomp);
	return nbits;
	}


	/* Ask for the curve. ALGO is the selected algorithm which this
	function may adjust. Returns a const string of the name of the
	curve. */
	const char *
	ask_curve (int algo, int subkey_algo, const char *current)
	{
	/* NB: We always use a complete algo list so that we have stable
	numbers in the menu regardless on how Gpg was configured. */
	struct {
	const char *name;
	const char* eddsa_curve; /* Corresponding EdDSA curve. */
	const char *pretty_name;
	unsigned int supported : 1; /* Supported by gpg. */
	unsigned int de_vs : 1; /* Allowed in CO_DE_VS. */
	unsigned int expert_only : 1; /* Only with --expert */
	unsigned int no_listing : 1; /* Do not show in the menu */
	unsigned int available : 1; /* Available in Libycrypt (runtime checked) */
	} curves[] = {
	#if GPG_USE_ECDSA \|\| GPG_USE_ECDH
	# define MY_USE_ECDSADH 1
	#else
	# define MY_USE_ECDSADH 0
	#endif
	{ "Curve25519", "Ed25519", "Curve 25519", !!GPG_USE_EDDSA, 0,0,0,0 },
	{ "X448", "Ed448", "Curve 448", !!GPG_USE_EDDSA, 0,1,0,0 },
	{ "NIST P-256", NULL, NULL, MY_USE_ECDSADH, 0,1,0,0 },
	{ "NIST P-384", NULL, NULL, MY_USE_ECDSADH, 0,0,0,0 },
	{ "NIST P-521", NULL, NULL, MY_USE_ECDSADH, 0,1,0,0 },
	{ "brainpoolP256r1", NULL, "Brainpool P-256", MY_USE_ECDSADH, 1,0,0,0 },
	{ "brainpoolP384r1", NULL, "Brainpool P-384", MY_USE_ECDSADH, 1,1,0,0 },
	{ "brainpoolP512r1", NULL, "Brainpool P-512", MY_USE_ECDSADH, 1,1,0,0 },
	{ "secp256k1", NULL, NULL, MY_USE_ECDSADH, 0,1,1,0 },
	};
	#undef MY_USE_ECDSADH
	int idx;
	char *answer;
	const char *result = NULL;
	gcry_sexp_t keyparms;

	tty_printf (_("Please select which elliptic curve you want:\n"));

	keyparms = NULL;
	for (idx=0; idx < DIM(curves); idx++)
	{
	int rc;

	curves[idx].available = 0;
	if (!curves[idx].supported)
	continue;

	if (opt.compliance==CO_DE_VS)
	{
	if (!curves[idx].de_vs)
	continue; /* Not allowed. */
	}
	else if (!opt.expert && curves[idx].expert_only)
	continue;

	/* We need to switch from the ECDH name of the curve to the
	EDDSA name of the curve if we want a signing key. */
	gcry_sexp_release (keyparms);
	rc = gcry_sexp_build (&keyparms, NULL,
	"(public-key(ecc(curve %s)))",
	curves[idx].eddsa_curve? curves[idx].eddsa_curve
	/**/ : curves[idx].name);
	if (rc)
	continue;
	if (!gcry_pk_get_curve (keyparms, 0, NULL))
	continue;
	if (subkey_algo && curves[idx].eddsa_curve)
	{
	/* Both Curve 25519 (or 448) keys are to be created. Check that
	Libgcrypt also supports the real Curve25519 (or 448). */
	gcry_sexp_release (keyparms);
	rc = gcry_sexp_build (&keyparms, NULL,
	"(public-key(ecc(curve %s)))",
	curves[idx].name);
	if (rc)
	continue;
	if (!gcry_pk_get_curve (keyparms, 0, NULL))
	continue;
	}

	curves[idx].available = 1;
	if (!curves[idx].no_listing)
	tty_printf (" (%d) %s%s\n", idx + 1,
	curves[idx].pretty_name?
	curves[idx].pretty_name:curves[idx].name,
	idx == 0? _(" default"):"");
	}
	gcry_sexp_release (keyparms);


	for (;;)
	{
	answer = cpr_get ("keygen.curve", _("Your selection? "));
	cpr_kill_prompt ();
	idx = *answer? atoi (answer) : 1;
	if (!*answer && current)
	{
	xfree(answer);
	return NULL;
	}
	else if (*answer && (!idx \|\| (idx > 0 && idx <= DIM (curves)
	&& curves[idx-1].no_listing)))
	{
	/* See whether the user entered the name of the curve. */
	for (idx=0; idx < DIM(curves); idx++)
	{
	if (!opt.expert && curves[idx].expert_only)
	continue;
	if (!stricmp (curves[idx].name, answer)
	\|\| (curves[idx].pretty_name
	&& !stricmp (curves[idx].pretty_name, answer)))
	break;
	}
	if (idx == DIM(curves))
	idx = -1;
	}
	else
	idx--;
	xfree(answer);
	answer = NULL;
	if (idx < 0 \|\| idx >= DIM (curves) \|\| !curves[idx].available)
	tty_printf (_("Invalid selection.\n"));
	else
	{
	/* If the user selected a signing algorithm and Curve25519
	we need to set the algo to EdDSA and update the curve name.
	If switching away from EdDSA, we need to set the algo back
	to ECDSA. */
	if (algo == PUBKEY_ALGO_ECDSA \|\| algo == PUBKEY_ALGO_EDDSA)
	{
	if (curves[idx].eddsa_curve)
	{
	if (subkey_algo && *subkey_algo == PUBKEY_ALGO_ECDSA)
	*subkey_algo = PUBKEY_ALGO_EDDSA;
	*algo = PUBKEY_ALGO_EDDSA;
	result = curves[idx].eddsa_curve;
	}
	else
	{
	if (subkey_algo && *subkey_algo == PUBKEY_ALGO_EDDSA)
	*subkey_algo = PUBKEY_ALGO_ECDSA;
	*algo = PUBKEY_ALGO_ECDSA;
	result = curves[idx].name;
	}
	}
	else
	result = curves[idx].name;
	break;
	}
	}

	if (!result)
	result = curves[0].name;

	return result;
	}


	/* Ask for the Kyber variant. Returns a const algo string like
	* kyber768_bp256 or NULL on error. */
	const char *
	ask_kyber_variant (void)
	{
	struct {
	const char desc; / e.g. "Kyber 768" */
	const char variant; / e.g. "kyber768_bp256" */
	unsigned int de_vs : 1; /* Allowed in CO_DE_VS. */
	} table[] = {
	{ "Kyber 768", "kyber768_bp256", 1 },
	{ "Kyber 1024", "kyber1024_bp384", 1 },
	{ "Kyber 768 (X25519)", "kyber768_cv25519", 0 },
	{ "Kyber 1024 (X448)", "kyber1024_cv448", 0 },
	};
	int idx;
	char *answer;
	const char *result = NULL;

	tty_printf (_("Please select the %s variant you want:\n"), "Kyber");

	for (idx=0; idx < DIM(table); idx++)
	{
	if (opt.compliance==CO_DE_VS)
	{
	if (!table[idx].de_vs)
	continue; /* Not allowed. */
	}

	tty_printf (" (%d) %s%s\n", idx + 1,
	table[idx].desc,
	idx == 0? _(" default"):"");
	}

	for (;;)
	{
	answer = cpr_get ("keygen.kyber_variant", _("Your selection? "));
	cpr_kill_prompt ();
	idx = answer? atoi (answer) : 1 / default */;
	if (*answer && !idx)
	{
	/* See whether the user entered the name of the algo. */
	for (idx=0; idx < DIM(table); idx++)
	{
	if (!stricmp (table[idx].variant, answer))
	break;
	}
	if (idx == DIM(table))
	idx = -1;
	}
	else
	idx--; /* Map back to 0 based index. */
	xfree(answer);
	answer = NULL;
	if (idx < 0 \|\| idx >= DIM (table)
	\|\| (opt.compliance==CO_DE_VS && !table[idx].de_vs))
	tty_printf (_("Invalid selection.\n"));
	else
	{
	result = table[idx].variant;
	break;
	}
	}

	if (!result)
	result = table[0].variant;

	return result;
	}


	/****************
	* Parse an expire string and return its value in seconds.
	* Returns (u32)-1 on error.
	* This isn't perfect since scan_isodatestr returns unix time, and
	* OpenPGP actually allows a 32-bit time plus a 32-bit offset.
	* Because of this, we only permit setting expirations up to 2106, but
	* OpenPGP could theoretically allow up to 2242. I think we'll all
	* just cope for the next few years until we get a 64-bit time_t or
	* similar.
	*/
	static u32
	parse_expire_string_with_ct (const char *string, u32 creation_time)
	{
	int mult;
	u32 seconds;
	u32 abs_date = 0;
	time_t tt;
	uint64_t tmp64;
	u32 curtime;

	if (creation_time == (u32)-1)
	curtime = make_timestamp ();
	else
	curtime = creation_time;

	if (!string \|\| !*string \|\| !strcmp (string, "none")
	\|\| !strcmp (string, "never") \|\| !strcmp (string, "-"))
	seconds = 0;
	else if (!strncmp (string, "seconds=", 8))
	seconds = scan_secondsstr (string+8);
	else if ((abs_date = scan_isodatestr(string))
	&& (abs_date+86400/2) > curtime)
	seconds = (abs_date+86400/2) - curtime;
	else if ((tt = isotime2epoch_u64 (string)) != (uint64_t)(-1))
	{
	tmp64 = tt - curtime;
	if (tmp64 >= (u32)(-1))
	seconds = (u32)(-1) - 1; /* cap value. */
	else
	seconds = (u32)tmp64;
	}
	else if ((mult = check_valid_days (string)))
	{
	tmp64 = scan_secondsstr (string) * 86400L * mult;
	if (tmp64 >= (u32)(-1))
	seconds = (u32)(-1) - 1; /* cap value. */
	else
	seconds = (u32)tmp64;
	}
	else
	seconds = (u32)(-1);

	return seconds;
	}

	u32
	parse_expire_string ( const char *string )
	{
	return parse_expire_string_with_ct (string, (u32)-1);
	}


	/* Parse a Creation-Date string which is either "1986-04-26" or
	"19860426T042640". Returns 0 on error. */
	static u32
	parse_creation_string (const char *string)
	{
	u32 seconds;

	if (!*string)
	seconds = 0;
	else if ( !strncmp (string, "seconds=", 8) )
	seconds = scan_secondsstr (string+8);
	else if ( !(seconds = scan_isodatestr (string)))
	{
	uint64_t tmp = isotime2epoch_u64 (string);
	if (tmp == (uint64_t)(-1))
	seconds = 0;
	else if (tmp > (u32)(-1))
	seconds = 0;
	else
	seconds = tmp;
	}
	return seconds;
	}


	/* object == 0 for a key, and 1 for a sig */
	u32
	ask_expire_interval(int object,const char *def_expire)
	{
	u32 interval;
	char *answer;

	switch(object)
	{
	case 0:
	if(def_expire)
	BUG();
	tty_printf(_("Please specify how long the key should be valid.\n"
	" 0 = key does not expire\n"
	" <n> = key expires in n days\n"
	" <n>w = key expires in n weeks\n"
	" <n>m = key expires in n months\n"
	" <n>y = key expires in n years\n"));
	break;

	case 1:
	if(!def_expire)
	BUG();
	tty_printf(_("Please specify how long the signature should be valid.\n"
	" 0 = signature does not expire\n"
	" <n> = signature expires in n days\n"
	" <n>w = signature expires in n weeks\n"
	" <n>m = signature expires in n months\n"
	" <n>y = signature expires in n years\n"));
	break;

	default:
	BUG();
	}

	/* Note: The elgamal subkey for DSA has no expiration date because
	* it must be signed with the DSA key and this one has the expiration
	* date */

	answer = NULL;
	for(;;)
	{
	u32 curtime;

	xfree(answer);
	if(object==0)
	answer = cpr_get("keygen.valid",_("Key is valid for? (0) "));
	else
	{
	char *prompt;

	prompt = xasprintf (_("Signature is valid for? (%s) "), def_expire);
	answer = cpr_get("siggen.valid",prompt);
	xfree(prompt);

	if(*answer=='\0')
	{
	xfree (answer);
	answer = xstrdup (def_expire);
	}
	}
	cpr_kill_prompt();
	trim_spaces(answer);
	curtime = make_timestamp ();
	interval = parse_expire_string( answer );
	if( interval == (u32)-1 )
	{
	tty_printf(_("invalid value\n"));
	continue;
	}

	if( !interval )
	{
	tty_printf((object==0)
	? _("Key does not expire at all\n")
	: _("Signature does not expire at all\n"));
	}
	else
	{
	tty_printf(object==0
	? _("Key expires at %s\n")
	: _("Signature expires at %s\n"),
	asctimestamp((ulong)(curtime + interval) ) );
	#if SIZEOF_TIME_T <= 4 && !defined (HAVE_UNSIGNED_TIME_T)
	if ( (time_t)((ulong)(curtime+interval)) < 0 )
	tty_printf (_("Your system can't display dates beyond 2038.\n"
	"However, it will be correctly handled up to"
	" 2106.\n"));
	else
	#endif /SIZEOF_TIME_T/
	if ( (time_t)((unsigned long)(curtime+interval)) < curtime )
	{
	tty_printf (_("invalid value\n"));
	continue;
	}
	}

	if( cpr_enabled() \|\| cpr_get_answer_is_yes("keygen.valid.okay",
	_("Is this correct? (y/N) ")) )
	break;
	}

	xfree(answer);
	return interval;
	}

	u32
	ask_expiredate (void)
	{
	u32 x = ask_expire_interval(0,NULL);
	return x? make_timestamp() + x : 0;
	}



	static PKT_user_id *
	uid_from_string (const char *string)
	{
	size_t n;
	PKT_user_id *uid;

	n = strlen (string);
	uid = xmalloc_clear (sizeof *uid + n);
	uid->len = n;
	strcpy (uid->name, string);
	uid->ref = 1;
	return uid;
	}


	/* Return true if the user id UID already exists in the keyblock. */
	static int
	uid_already_in_keyblock (kbnode_t keyblock, const char *uid)
	{
	PKT_user_id *uidpkt = uid_from_string (uid);
	kbnode_t node;
	int result = 0;

	for (node=keyblock; node && !result; node=node->next)
	if (!is_deleted_kbnode (node)
	&& node->pkt->pkttype == PKT_USER_ID
	&& !cmp_user_ids (uidpkt, node->pkt->pkt.user_id))
	result = 1;
	free_user_id (uidpkt);
	return result;
	}


	/* Ask for a user ID. With a MODE of 1 an extra help prompt is
	printed for use during a new key creation. If KEYBLOCK is not NULL
	the function prevents the creation of an already existing user
	ID. IF FULL is not set some prompts are not shown. */
	static char *
	ask_user_id (int mode, int full, KBNODE keyblock)
	{
	char *answer;
	char aname, acomment, amail, uid;

	if ( !mode )
	{
	/* TRANSLATORS: This is the new string telling the user what
	gpg is now going to do (i.e. ask for the parts of the user
	ID). Note that if you do not translate this string, a
	different string will be used, which might still have
	a correct translation. */
	const char *s1 =
	N_("\n"
	"GnuPG needs to construct a user ID to identify your key.\n"
	"\n");
	const char *s2 = _(s1);

	if (!strcmp (s1, s2))
	{
	/* There is no translation for the string thus we to use
	the old info text. gettext has no way to tell whether
	a translation is actually available, thus we need to
	to compare again. */
	/* TRANSLATORS: This string is in general not anymore used
	but you should keep your existing translation. In case
	the new string is not translated this old string will
	be used. */
	const char *s3 = N_("\n"
	"You need a user ID to identify your key; "
	"the software constructs the user ID\n"
	"from the Real Name, Comment and Email Address in this form:\n"
	" \"Heinrich Heine (Der Dichter) <heinrichh@duesseldorf.de>\"\n\n");
	const char *s4 = _(s3);
	if (strcmp (s3, s4))
	s2 = s3; /* A translation exists - use it. */
	}
	tty_printf ("%s", s2) ;
	}
	uid = aname = acomment = amail = NULL;
	for(;;) {
	char *p;
	int fail=0;

	if( !aname ) {
	for(;;) {
	xfree(aname);
	aname = cpr_get("keygen.name",_("Real name: "));
	trim_spaces(aname);
	cpr_kill_prompt();

	if( opt.allow_freeform_uid )
	break;

	if( strpbrk( aname, "<>" ) )
	{
	tty_printf(_("Invalid character in name\n"));
	tty_printf(_("The characters '%s' and '%s' may not "
	"appear in name\n"), "<", ">");
	}
	else
	break;
	}
	}
	if( !amail ) {
	for(;;) {
	xfree(amail);
	amail = cpr_get("keygen.email",_("Email address: "));
	trim_spaces(amail);
	cpr_kill_prompt();
	if( !*amail \|\| opt.allow_freeform_uid )
	break; /* no email address is okay */
	else if ( !is_valid_mailbox (amail) )
	tty_printf(_("Not a valid email address\n"));
	else
	break;
	}
	}
	if (!acomment) {
	if (full) {
	for(;;) {
	xfree(acomment);
	acomment = cpr_get("keygen.comment",_("Comment: "));
	trim_spaces(acomment);
	cpr_kill_prompt();
	if( !*acomment )
	break; /* no comment is okay */
	else if( strpbrk( acomment, "()" ) )
	tty_printf(_("Invalid character in comment\n"));
	else
	break;
	}
	}
	else {
	xfree (acomment);
	acomment = xstrdup ("");
	}
	}


	xfree(uid);
	uid = p = xmalloc(strlen(aname)+strlen(amail)+strlen(acomment)+12+10);
	if (!aname && amail && !*acomment && !random_is_faked ())
	{ /* Empty name and comment but with mail address. Use
	simplified form with only the non-angle-bracketed mail
	address. */
	p = stpcpy (p, amail);
	}
	else
	{
	p = stpcpy (p, aname );
	if (*acomment)
	p = stpcpy(stpcpy(stpcpy(p," ("), acomment),")");
	if (*amail)
	p = stpcpy(stpcpy(stpcpy(p," <"), amail),">");
	}

	/* Append a warning if the RNG is switched into fake mode. */
	if ( random_is_faked () )
	strcpy(p, " (insecure!)" );

	/* print a note in case that UTF8 mapping has to be done */
	for(p=uid; *p; p++ ) {
	if( *p & 0x80 ) {
	tty_printf(_("You are using the '%s' character set.\n"),
	get_native_charset() );
	break;
	}
	}

	tty_printf(_("You selected this USER-ID:\n \"%s\"\n\n"), uid);

	if( !*amail && !opt.allow_freeform_uid
	&& (strchr( aname, '@' ) \|\| strchr( acomment, '@'))) {
	fail = 1;
	tty_printf(_("Please don't put the email address "
	"into the real name or the comment\n") );
	}

	if (!fail && keyblock)
	{
	if (uid_already_in_keyblock (keyblock, uid))
	{
	tty_printf (_("Such a user ID already exists on this key!\n"));
	fail = 1;
	}
	}

	for(;;) {
	/* TRANSLATORS: These are the allowed answers in
	lower and uppercase. Below you will find the matching
	string which should be translated accordingly and the
	letter changed to match the one in the answer string.

	n = Change name
	c = Change comment
	e = Change email
	o = Okay (ready, continue)
	q = Quit
	*/
	const char *ansstr = _("NnCcEeOoQq");

	if( strlen(ansstr) != 10 )
	BUG();
	if( cpr_enabled() ) {
	answer = xstrdup (ansstr + (fail?8:6));
	answer[1] = 0;
	}
	else if (full) {
	answer = cpr_get("keygen.userid.cmd", fail?
	_("Change (N)ame, (C)omment, (E)mail or (Q)uit? ") :
	_("Change (N)ame, (C)omment, (E)mail or (O)kay/(Q)uit? "));
	cpr_kill_prompt();
	}
	else {
	answer = cpr_get("keygen.userid.cmd", fail?
	_("Change (N)ame, (E)mail, or (Q)uit? ") :
	_("Change (N)ame, (E)mail, or (O)kay/(Q)uit? "));
	cpr_kill_prompt();
	}
	if( strlen(answer) > 1 )
	;
	else if( answer == ansstr[0] \|\| answer == ansstr[1] ) {
	xfree(aname); aname = NULL;
	break;
	}
	else if( answer == ansstr[2] \|\| answer == ansstr[3] ) {
	xfree(acomment); acomment = NULL;
	break;
	}
	else if( answer == ansstr[4] \|\| answer == ansstr[5] ) {
	xfree(amail); amail = NULL;
	break;
	}
	else if( answer == ansstr[6] \|\| answer == ansstr[7] ) {
	if( fail ) {
	tty_printf(_("Please correct the error first\n"));
	}
	else {
	xfree(aname); aname = NULL;
	xfree(acomment); acomment = NULL;
	xfree(amail); amail = NULL;
	break;
	}
	}
	else if( answer == ansstr[8] \|\| answer == ansstr[9] ) {
	xfree(aname); aname = NULL;
	xfree(acomment); acomment = NULL;
	xfree(amail); amail = NULL;
	xfree(uid); uid = NULL;
	break;
	}
	xfree(answer);
	}
	xfree(answer);
	if (!amail && !acomment)
	break;
	xfree(uid); uid = NULL;
	}
	if( uid ) {
	char *p = native_to_utf8( uid );
	xfree( uid );
	uid = p;
	}
	return uid;
	}


	/* Basic key generation. Here we divert to the actual generation
	* routines based on the requested algorithm. KEYGEN_FLAGS might be
	* updated by this function. */
	static int
	do_create (int algo, unsigned int nbits, const char *curve, kbnode_t pub_root,
	u32 timestamp, u32 expiredate, int is_subkey,
	int keygen_flags, const char passphrase,
	char cache_nonce_addr, char passwd_nonce_addr,
	gpg_error_t (*common_gen_cb)(common_gen_cb_parm_t),
	common_gen_cb_parm_t common_gen_cb_parm)
	{
	gpg_error_t err;

	/* Fixme: The entropy collecting message should be moved to a
	libgcrypt progress handler. */
	if (!opt.batch)
	tty_printf (_(
	"We need to generate a lot of random bytes. It is a good idea to perform\n"
	"some other action (type on the keyboard, move the mouse, utilize the\n"
	"disks) during the prime generation; this gives the random number\n"
	"generator a better chance to gain enough entropy.\n") );

	if (algo == PUBKEY_ALGO_ELGAMAL_E)
	err = gen_elg (algo, nbits, pub_root, timestamp, expiredate, is_subkey,
	*keygen_flags, passphrase,
	cache_nonce_addr, passwd_nonce_addr,
	common_gen_cb, common_gen_cb_parm);
	else if (algo == PUBKEY_ALGO_DSA)
	err = gen_dsa (nbits, pub_root, timestamp, expiredate, is_subkey,
	*keygen_flags, passphrase,
	cache_nonce_addr, passwd_nonce_addr,
	common_gen_cb, common_gen_cb_parm);
	else if (algo == PUBKEY_ALGO_ECDSA
	\|\| algo == PUBKEY_ALGO_EDDSA
	\|\| algo == PUBKEY_ALGO_ECDH)
	err = gen_ecc (algo, curve, pub_root, timestamp, expiredate, is_subkey,
	keygen_flags, passphrase,
	cache_nonce_addr, passwd_nonce_addr,
	common_gen_cb, common_gen_cb_parm);
	else if (algo == PUBKEY_ALGO_KYBER)
	err = gen_kyber (algo, nbits, curve,
	pub_root, timestamp, expiredate, is_subkey,
	keygen_flags, passphrase,
	cache_nonce_addr, passwd_nonce_addr,
	common_gen_cb, common_gen_cb_parm);
	else if (algo == PUBKEY_ALGO_RSA)
	err = gen_rsa (algo, nbits, pub_root, timestamp, expiredate, is_subkey,
	*keygen_flags, passphrase,
	cache_nonce_addr, passwd_nonce_addr,
	common_gen_cb, common_gen_cb_parm);
	else
	BUG();

	return err;
	}


	/* Generate a new user id packet or return NULL if canceled. If
	KEYBLOCK is not NULL the function prevents the creation of an
	already existing user ID. If UIDSTR is not NULL the user is not
	asked but UIDSTR is used to create the user id packet; if the user
	id already exists NULL is returned. UIDSTR is expected to be utf-8
	encoded and should have already been checked for a valid length
	etc. */
	PKT_user_id *
	generate_user_id (KBNODE keyblock, const char *uidstr)
	{
	PKT_user_id *uid;
	char *p;

	if (uidstr)
	{
	if (uid_already_in_keyblock (keyblock, uidstr))
	return NULL; /* Already exists. */
	uid = uid_from_string (uidstr);
	}
	else
	{
	p = ask_user_id (1, 1, keyblock);
	if (!p)
	return NULL; /* Canceled. */
	uid = uid_from_string (p);
	xfree (p);
	}
	return uid;
	}


	/* Helper for parse_key_parameter_part_parameter_string for one part of the
	* specification string; i.e. ALGO/FLAGS. If STRING is NULL or empty
	* success is returned. On error an error code is returned. Note
	* that STRING may be modified by this function. NULL may be passed
	* for any parameter. FOR_SUBKEY shall be true if this is used as a
	* subkey. If CLEAR_CERT is set a default CERT usage will be cleared;
	* this is useful if for example the default algorithm is used for a
	* subkey. If R_KEYVERSION is not NULL it will receive the version of
	* the key; this is currently 4 but can be changed with the flag "v5"
	* to create a v5 key. If R_KEYTIME is not NULL and the key has been
	* taken from active OpenPGP card, its creation time is stored
	* there. */
	static gpg_error_t
	parse_key_parameter_part (ctrl_t ctrl,
	char *string, int for_subkey, int clear_cert,
	int r_algo, unsigned int r_size,
	unsigned int *r_keyuse,
	char const *r_curve, int r_keyversion,
	char *r_keygrip, u32 r_keytime)
	{
	gpg_error_t err;
	char *flags;
	int algo;
	char *endp;
	const char *curve = NULL;
	int ecdh_or_ecdsa = 0;
	unsigned int size;
	int keyuse;
	int keyversion = 0; /* Not specified. */
	int i;
	const char *s;
	int from_card = 0;
	char *keygrip = NULL;
	u32 keytime = 0;
	int is_448 = 0;
	int is_pqc = 0;

	if (!string \|\| !*string)
	return 0; /* Success. */

	flags = strchr (string, '/');
	if (flags)
	*flags++ = 0;

	algo = 0;
	if (!ascii_strcasecmp (string, "card"))
	from_card = 1;
	else if (strlen (string) >= 3 && (digitp (string+3) \|\| !string[3]))
	{
	if (!ascii_memcasecmp (string, "rsa", 3))
	algo = PUBKEY_ALGO_RSA;
	else if (!ascii_memcasecmp (string, "dsa", 3))
	algo = PUBKEY_ALGO_DSA;
	else if (!ascii_memcasecmp (string, "elg", 3))
	algo = PUBKEY_ALGO_ELGAMAL_E;
	}

	if (from_card)
	; /* We need the flags before we can figure out the key to use. */
	else if (algo)
	{
	/* This is one of the algos parsed above (rsa, dsa, or elg). */
	if (!string[3])
	size = get_keysize_range (algo, NULL, NULL);
	else
	{
	size = strtoul (string+3, &endp, 10);
	if (size < 512 \|\| size > 16384 \|\| *endp)
	return gpg_error (GPG_ERR_INV_VALUE);
	}
	}
	else if (!ascii_strcasecmp (string, "kyber")
	\|\| !ascii_strcasecmp (string, "kyber768"))
	{
	/* Get the curve and check that it can technically be used
	* (i.e. everything except the EdXXXX curves. */
	curve = openpgp_is_curve_supported ("brainpoolP256r1", &algo, NULL);
	if (!curve \|\| algo == PUBKEY_ALGO_EDDSA)
	return gpg_error (GPG_ERR_UNKNOWN_CURVE);
	algo = PUBKEY_ALGO_KYBER;
	size = 768;
	is_pqc = 1;
	}
	else if (!ascii_strcasecmp (string, "kyber1024"))
	{
	/* Get the curve and check that it can technically be used
	* (i.e. everything except the EdXXXX curves. */
	curve = openpgp_is_curve_supported ("brainpoolP384r1", &algo, NULL);
	if (!curve \|\| algo == PUBKEY_ALGO_EDDSA)
	return gpg_error (GPG_ERR_UNKNOWN_CURVE);
	algo = PUBKEY_ALGO_KYBER;
	size = 1024;
	is_pqc = 1;
	}
	else if (!ascii_strncasecmp (string, "ky768_", 6)
	\|\| !ascii_strncasecmp (string, "ky1024_", 7)
	\|\| !ascii_strncasecmp (string, "kyber768_", 9)
	\|\| !ascii_strncasecmp (string, "kyber1024_", 10)
	)
	{
	/* Get the curve and check that it can technically be used
	* (i.e. everything except the EdXXXX curves. */
	s = strchr (string, '_');
	log_assert (s);
	s++;
	curve = openpgp_is_curve_supported (s, &algo, NULL);
	if (!curve \|\| algo == PUBKEY_ALGO_EDDSA)
	return gpg_error (GPG_ERR_UNKNOWN_CURVE);
	algo = PUBKEY_ALGO_KYBER;
	size = strstr (string, "768_")? 768 : 1024;
	is_pqc = 1;
	}
	else if (!ascii_strcasecmp (string, "dil3"))
	{
	algo = PUBKEY_ALGO_DIL3_25519;
	is_pqc = 1;
	}
	else if (!ascii_strcasecmp (string, "dil5"))
	{
	algo = PUBKEY_ALGO_DIL5_448;
	is_pqc = 1;
	}
	else if (!ascii_strcasecmp (string, "sphinx")
	\|\| !ascii_strcasecmp (string, "sphinx_sha2"))
	{
	algo = PUBKEY_ALGO_SPHINX_SHA2;
	is_pqc = 1;
	}
	else if ((curve = openpgp_is_curve_supported (string, &algo, &size)))
	{
	if (!algo)
	{
	algo = PUBKEY_ALGO_ECDH; /* Default ECC algorithm. */
	ecdh_or_ecdsa = 1; /* We may need to switch the algo. */
	}
	if (curve && (!strcmp (curve, "X448") \|\| !strcmp (curve, "Ed448")))
	is_448 = 1;
	}
	else
	return gpg_error (GPG_ERR_UNKNOWN_CURVE);

	/* Parse the flags. */
	keyuse = 0;
	if (flags)
	{
	char **tokens = NULL;

	tokens = strtokenize (flags, ",");
	if (!tokens)
	return gpg_error_from_syserror ();

	for (i=0; (s = tokens[i]); i++)
	{
	if (!*s)
	;
	else if (!ascii_strcasecmp (s, "sign"))
	keyuse \|= PUBKEY_USAGE_SIG;
	else if (!ascii_strcasecmp (s, "encrypt")
	\|\| !ascii_strcasecmp (s, "encr"))
	keyuse \|= PUBKEY_USAGE_ENC;
	else if (!ascii_strcasecmp (s, "auth"))
	keyuse \|= PUBKEY_USAGE_AUTH;
	else if (!ascii_strcasecmp (s, "cert"))
	keyuse \|= PUBKEY_USAGE_CERT;
	else if (!ascii_strcasecmp (s, "ecdsa") && !from_card)
	{
	if (algo == PUBKEY_ALGO_ECDH \|\| algo == PUBKEY_ALGO_ECDSA)
	algo = PUBKEY_ALGO_ECDSA;
	else
	{
	xfree (tokens);
	return gpg_error (GPG_ERR_INV_FLAG);
	}
	ecdh_or_ecdsa = 0;
	}
	else if (!ascii_strcasecmp (s, "ecdh") && !from_card)
	{
	if (algo == PUBKEY_ALGO_ECDH \|\| algo == PUBKEY_ALGO_ECDSA)
	algo = PUBKEY_ALGO_ECDH;
	else
	{
	xfree (tokens);
	return gpg_error (GPG_ERR_INV_FLAG);
	}
	ecdh_or_ecdsa = 0;
	}
	else if (!ascii_strcasecmp (s, "eddsa") && !from_card)
	{
	/* Not required but we allow it for consistency. */
	if (algo == PUBKEY_ALGO_EDDSA)
	;
	else
	{
	xfree (tokens);
	return gpg_error (GPG_ERR_INV_FLAG);
	}
	}
	else if (!ascii_strcasecmp (s, "v5"))
	keyversion = 5;
	else if (!ascii_strcasecmp (s, "v4"))
	keyversion = 4;
	else
	{
	xfree (tokens);
	return gpg_error (GPG_ERR_UNKNOWN_FLAG);
	}
	}

	xfree (tokens);
	}

	/* If not yet decided switch between ecdh and ecdsa unless we want
	* to read the algo from the current card. */
	if (from_card)
	{
	keypair_info_t keypairlist, kpi;
	char *reqkeyref;

	if (!keyuse)
	keyuse = (for_subkey? PUBKEY_USAGE_ENC
	/* */ : (PUBKEY_USAGE_CERT\|PUBKEY_USAGE_SIG));

	/* Access the card to make sure we have one and to show the S/N. */
	{
	char *serialno;

	err = agent_scd_serialno (&serialno, NULL);
	if (err)
	{
	log_error (_("error reading the card: %s\n"), gpg_strerror (err));
	return err;
	}
	if (!opt.quiet)
	log_info (_("Serial number of the card: %s\n"), serialno);
	xfree (serialno);
	}

	err = agent_scd_keypairinfo (ctrl, NULL, &keypairlist);
	if (err)
	{
	log_error (_("error reading the card: %s\n"), gpg_strerror (err));
	return err;
	}
	agent_scd_getattr_one ((keyuse & (PUBKEY_USAGE_SIG\|PUBKEY_USAGE_CERT))
	? "$SIGNKEYID":"$ENCRKEYID", &reqkeyref);

	algo = 0; /* Should already be the case. */
	for (kpi=keypairlist; kpi && !algo; kpi = kpi->next)
	{
	gcry_sexp_t s_pkey;
	char *algostr = NULL;
	enum gcry_pk_algos algoid = 0;
	const char *keyref = kpi->idstr;

	if (!reqkeyref)
	continue; /* Card does not provide the info (skip all). */

	if (!keyref)
	continue; /* Ooops. */
	if (strcmp (reqkeyref, keyref))
	continue; /* This is not the requested keyref. */

	if ((keyuse & (PUBKEY_USAGE_SIG\|PUBKEY_USAGE_CERT))
	&& (kpi->usage & (GCRY_PK_USAGE_SIGN\|GCRY_PK_USAGE_CERT)))
	; /* Okay */
	else if ((keyuse & PUBKEY_USAGE_ENC)
	&& (kpi->usage & GCRY_PK_USAGE_ENCR))
	; /* Okay */
	else
	continue; /* Not usable for us. */

	if (agent_scd_readkey (ctrl, keyref, &s_pkey, NULL))
	continue; /* Could not read the key. */

	algostr = pubkey_algo_string (s_pkey, &algoid);
	gcry_sexp_release (s_pkey);

	/* Map to OpenPGP algo number.
	* We need to tweak the algo in case GCRY_PK_ECC is
	* returned because pubkey_algo_string is not aware
	* of the OpenPGP algo mapping. We need to
	* distinguish between ECDH and ECDSA but we can do
	* that only if we got usage flags.
	* Note: Keep this in sync with ask_algo. */
	if (algoid == GCRY_PK_ECC && algostr)
	{
	if (!strcmp (algostr, "ed25519"))
	algo = PUBKEY_ALGO_EDDSA;
	else if (!strcmp (algostr, "ed448"))
	{
	algo = PUBKEY_ALGO_EDDSA;
	is_448 = 1;
	}
	else if (!strcmp (algostr, "cv25519"))
	algo = PUBKEY_ALGO_ECDH;
	else if (!strcmp (algostr, "cv448"))
	{
	algo = PUBKEY_ALGO_ECDH;
	is_448 = 1;
	}
	else if ((kpi->usage & GCRY_PK_USAGE_ENCR))
	algo = PUBKEY_ALGO_ECDH;
	else
	algo = PUBKEY_ALGO_ECDSA;
	}
	else
	algo = map_gcry_pk_to_openpgp (algoid);

	xfree (algostr);
	xfree (keygrip);
	keygrip = xtrystrdup (kpi->keygrip);
	if (!keygrip)
	{
	err = gpg_error_from_syserror ();
	xfree (reqkeyref);
	free_keypair_info (keypairlist);
	return err;
	}
	keytime = kpi->keytime;
	}

	xfree (reqkeyref);
	free_keypair_info (keypairlist);
	if (!algo \|\| !keygrip)
	{
	err = gpg_error (GPG_ERR_PUBKEY_ALGO);
	log_error ("no usable key on the card: %s\n", gpg_strerror (err));
	xfree (keygrip);
	return err;
	}
	}
	else if (ecdh_or_ecdsa && keyuse)
	algo = (keyuse & PUBKEY_USAGE_ENC)? PUBKEY_ALGO_ECDH : PUBKEY_ALGO_ECDSA;
	else if (ecdh_or_ecdsa)
	algo = for_subkey? PUBKEY_ALGO_ECDH : PUBKEY_ALGO_ECDSA;

	/* Set or fix key usage. */
	if (!keyuse)
	{
	if (algo == PUBKEY_ALGO_ECDSA \|\| algo == PUBKEY_ALGO_EDDSA
	\|\| algo == PUBKEY_ALGO_DSA)
	keyuse = PUBKEY_USAGE_SIG;
	else if (algo == PUBKEY_ALGO_RSA)
	keyuse = for_subkey? PUBKEY_USAGE_ENC : PUBKEY_USAGE_SIG;
	else
	keyuse = PUBKEY_USAGE_ENC;
	}
	else if (algo == PUBKEY_ALGO_ECDSA \|\| algo == PUBKEY_ALGO_EDDSA
	\|\| algo == PUBKEY_ALGO_DSA)
	{
	keyuse &= ~PUBKEY_USAGE_ENC; /* Forbid encryption. */
	}
	else if (algo == PUBKEY_ALGO_ECDH \|\| algo == PUBKEY_ALGO_ELGAMAL_E)
	{
	keyuse = PUBKEY_USAGE_ENC; /* Allow only encryption. */
	}

	/* Make sure a primary key can certify. */
	if (!for_subkey)
	keyuse \|= PUBKEY_USAGE_CERT;

	/* But if requested remove th cert usage. */
	if (clear_cert)
	keyuse &= ~PUBKEY_USAGE_CERT;

	/* Check that usage is actually possible. */
	if (/**/((keyuse & (PUBKEY_USAGE_SIG\|PUBKEY_USAGE_AUTH\|PUBKEY_USAGE_CERT))
	&& !pubkey_get_nsig (algo))
	\|\| ((keyuse & PUBKEY_USAGE_ENC)
	&& !pubkey_get_nenc (algo))
	\|\| (for_subkey && (keyuse & PUBKEY_USAGE_CERT)))
	{
	xfree (keygrip);
	return gpg_error (GPG_ERR_WRONG_KEY_USAGE);
	}

	/* Ed448, X448 and the PQC algos must only be used as v5 keys. */
	if (is_448 \|\| is_pqc)
	{
	if (keyversion == 4)
	log_info (_("WARNING: v4 is specified, but overridden by v5.\n"));

	keyversion = 5;
	}
	else if (keyversion == 0)
	keyversion = 4;

	/* Return values. */
	if (r_algo)
	*r_algo = algo;
	if (r_size)
	{
	unsigned int min, def, max;

	/* Make sure the keysize is in the allowed range. */
	def = get_keysize_range (algo, &min, &max);
	if (!size)
	size = def;
	else if (size < min)
	size = min;
	else if (size > max)
	size = max;

	*r_size = fixup_keysize (size, algo, 1);
	}

	if (r_keyuse)
	*r_keyuse = keyuse;
	if (r_curve)
	*r_curve = curve;
	if (r_keyversion)
	*r_keyversion = keyversion;

	if (r_keygrip)
	*r_keygrip = keygrip;
	else
	xfree (keygrip);

	if (r_keytime)
	*r_keytime = keytime;

	return 0;
	}


	/* Parse and return the standard key generation parameter.
	* The string is expected to be in this format:
	*
	* ALGO[/FLAGS][+SUBALGO[/FLAGS]]
	*
	* Here ALGO is a string in the same format as printed by the
	* keylisting. For example:
	*
	* rsa3072 := RSA with 3072 bit.
	* dsa2048 := DSA with 2048 bit.
	* elg2048 := Elgamal with 2048 bit.
	* ed25519 := EDDSA using curve Ed25519.
	* ed448 := EDDSA using curve Ed448.
	* cv25519 := ECDH using curve Curve25519.
	* cv448 := ECDH using curve X448.
	* nistp256:= ECDSA or ECDH using curve NIST P-256
	* kyber := Kyber with the default parameters
	* ky768_bp384 := Kyber-768 with BrainpoolP256r1 as second algo
	*
	* All strings with an unknown prefix are considered an elliptic
	* curve. Curves which have no implicit algorithm require that FLAGS
	* is given to select whether ECDSA or ECDH is used; this can either
	* be done using an algorithm keyword or usage keywords.
	*
	* FLAGS is a comma delimited string of keywords:
	*
	* cert := Allow usage Certify
	* sign := Allow usage Sign
	* encr := Allow usage Encrypt
	* auth := Allow usage Authentication
	* encrypt := Alias for "encr"
	* ecdsa := Use algorithm ECDSA.
	* eddsa := Use algorithm EdDSA.
	* ecdh := Use algorithm ECDH.
	* v5 := Create version 5 key
	*
	* There are several defaults and fallbacks depending on the
	* algorithm. PART can be used to select which part of STRING is
	* used:
	* -1 := Both parts
	* 0 := Only the part of the primary key
	* 1 := If there is one part parse that one, if there are
	* two parts parse the part which best matches the
	* SUGGESTED_USE or in case that can't be evaluated the second part.
	* Always return using the args for the primary key (R_ALGO,....).
	*
	*/
	gpg_error_t
	parse_key_parameter_string (ctrl_t ctrl,
	const char *string, int part,
	unsigned int suggested_use,
	int r_algo, unsigned int r_size,
	unsigned int *r_keyuse,
	char const **r_curve,
	int *r_version,
	char **r_keygrip,
	u32 *r_keytime,
	int r_subalgo, unsigned int r_subsize,
	unsigned int *r_subkeyuse,
	char const **r_subcurve,
	int *r_subversion,
	char **r_subkeygrip,
	u32 *r_subkeytime)
	{
	gpg_error_t err = 0;
	char primary, secondary;

	if (r_algo)
	*r_algo = 0;
	if (r_size)
	*r_size = 0;
	if (r_keyuse)
	*r_keyuse = 0;
	if (r_curve)
	*r_curve = NULL;
	if (r_version)
	*r_version = 4;
	if (r_keygrip)
	*r_keygrip = NULL;
	if (r_keytime)
	*r_keytime = 0;
	if (r_subalgo)
	*r_subalgo = 0;
	if (r_subsize)
	*r_subsize = 0;
	if (r_subkeyuse)
	*r_subkeyuse = 0;
	if (r_subcurve)
	*r_subcurve = NULL;
	if (r_subversion)
	*r_subversion = 4;
	if (r_subkeygrip)
	*r_subkeygrip = NULL;
	if (r_subkeytime)
	*r_subkeytime = 0;

	if (!string \|\| !*string
	\|\| !ascii_strcasecmp (string, "default") \|\| !strcmp (string, "-"))
	string = get_default_pubkey_algo ();
	else if (!ascii_strcasecmp (string, "future-default")
	\|\| !ascii_strcasecmp (string, "futuredefault"))
	string = FUTURE_STD_KEY_PARAM;
	else if (!ascii_strcasecmp (string, "pqc"))
	string = PQC_STD_KEY_PARAM;
	else if (!ascii_strcasecmp (string, "card"))
	string = "card/cert,sign+card/encr";

	primary = xstrdup (string);
	secondary = strchr (primary, '+');
	if (secondary)
	*secondary++ = 0;
	if (part == -1 \|\| part == 0)
	{
	err = parse_key_parameter_part (ctrl, primary,
	0, 0, r_algo, r_size,
	r_keyuse, r_curve, r_version,
	r_keygrip, r_keytime);
	if (!err && part == -1)
	err = parse_key_parameter_part (ctrl, secondary,
	1, 0, r_subalgo, r_subsize,
	r_subkeyuse, r_subcurve, r_subversion,
	r_subkeygrip, r_subkeytime);
	}
	else if (part == 1)
	{
	/* If we have SECONDARY, use that part. If there is only one
	* part consider this to be the subkey algo. In case a
	* SUGGESTED_USE has been given and the usage of the secondary
	* part does not match SUGGESTED_USE try again using the primary
	* part. Note that when falling back to the primary key we need
	* to force clearing the cert usage. */
	if (secondary)
	{
	err = parse_key_parameter_part (ctrl, secondary,
	1, 0,
	r_algo, r_size, r_keyuse, r_curve,
	r_version, r_keygrip, r_keytime);
	if (!err && suggested_use && r_keyuse && !(suggested_use & *r_keyuse))
	err = parse_key_parameter_part (ctrl, primary,
	1, 1 /(clear cert)/,
	r_algo, r_size, r_keyuse, r_curve,
	r_version, r_keygrip, r_keytime);
	}
	else
	err = parse_key_parameter_part (ctrl, primary,
	1, 0,
	r_algo, r_size, r_keyuse, r_curve,
	r_version, r_keygrip, r_keytime);
	}

	xfree (primary);

	return err;
	}



	/* Append R to the linked list PARA. */
	static void
	append_to_parameter (struct para_data_s para, struct para_data_s r)
	{
	log_assert (para);
	while (para->next)
	para = para->next;
	para->next = r;
	}

	/* Release the parameter list R. */
	static void
	release_parameter_list (struct para_data_s *r)
	{
	struct para_data_s *r2;

	for (; r ; r = r2)
	{
	r2 = r->next;
	if (r->key == pPASSPHRASE && *r->u.value)
	wipememory (r->u.value, strlen (r->u.value));
	else if (r->key == pADSK)
	free_public_key (r->u.adsk);

	xfree (r);
	}
	}

	/* Return the N-th parameter of name KEY from PARA. An IDX of 0
	* returns the first and so on. */
	static struct para_data_s *
	get_parameter_idx (struct para_data_s *para, enum para_name key,
	unsigned int idx)
	{
	struct para_data_s *r;

	for(r = para; r; r = r->next)
	if (r->key == key)
	{
	if (!idx)
	return r;
	idx--;
	}
	return NULL;
	}

	/* Return the first parameter of name KEY from PARA. */
	static struct para_data_s *
	get_parameter (struct para_data_s *para, enum para_name key)
	{
	return get_parameter_idx (para, key, 0);
	}

	static const char *
	get_parameter_value( struct para_data_s *para, enum para_name key )
	{
	struct para_data_s *r = get_parameter( para, key );
	return (r && *r->u.value)? r->u.value : NULL;
	}


	/* This is similar to get_parameter_value but also returns the empty
	string. This is required so that quick_generate_keypair can use an
	empty Passphrase to specify no-protection. */
	static const char *
	get_parameter_passphrase (struct para_data_s *para)
	{
	struct para_data_s *r = get_parameter (para, pPASSPHRASE);
	return r ? r->u.value : NULL;
	}


	static int
	get_parameter_algo (ctrl_t ctrl, struct para_data_s *para, enum para_name key,
	int *r_default)
	{
	int i;
	struct para_data_s *r = get_parameter( para, key );

	if (r_default)
	*r_default = 0;

	if (!r)
	return -1;

	/* Note that we need to handle the ECC algorithms specified as
	strings directly because Libgcrypt folds them all to ECC. */
	if (!ascii_strcasecmp (r->u.value, "default"))
	{
	/* Note: If you change this default algo, remember to change it
	* also in gpg.c:gpgconf_list. */
	/* FIXME: We only allow the algo here and have a separate thing
	* for the curve etc. That is a ugly but demanded for backward
	* compatibility with the batch key generation. It would be
	* better to make full use of parse_key_parameter_string. */
	parse_key_parameter_string (ctrl, NULL, 0, 0,
	&i, NULL, NULL, NULL, NULL, NULL, NULL,
	NULL, NULL, NULL, NULL, NULL, NULL, NULL);
	if (r_default)
	*r_default = 1;
	}
	else if (digitp (r->u.value))
	i = atoi( r->u.value );
	else if (!strcmp (r->u.value, "ELG-E")
	\|\| !strcmp (r->u.value, "ELG"))
	i = PUBKEY_ALGO_ELGAMAL_E;
	else if (!ascii_strcasecmp (r->u.value, "EdDSA"))
	i = PUBKEY_ALGO_EDDSA;
	else if (!ascii_strcasecmp (r->u.value, "ECDSA"))
	i = PUBKEY_ALGO_ECDSA;
	else if (!ascii_strcasecmp (r->u.value, "ECDH"))
	i = PUBKEY_ALGO_ECDH;
	else if (!ascii_strcasecmp (r->u.value, "KYBER"))
	i = PUBKEY_ALGO_KYBER;
	else
	i = map_gcry_pk_to_openpgp (gcry_pk_map_name (r->u.value));

	if (i == PUBKEY_ALGO_RSA_E \|\| i == PUBKEY_ALGO_RSA_S)
	i = 0; /* we don't want to allow generation of these algorithms */
	return i;
	}


	/* Parse a usage string. The usage keywords "auth", "sign", "encr"
	* may be delimited by space, tab, or comma. On error -1 is returned
	* instead of the usage flags. */
	static int
	parse_usagestr (const char *usagestr)
	{
	gpg_error_t err;
	char **tokens = NULL;
	const char *s;
	int i;
	unsigned int use = 0;

	tokens = strtokenize (usagestr, " \t,");
	if (!tokens)
	{
	err = gpg_error_from_syserror ();
	log_error ("strtokenize failed: %s\n", gpg_strerror (err));
	return -1;
	}

	for (i=0; (s = tokens[i]); i++)
	{
	if (!*s)
	;
	else if (!ascii_strcasecmp (s, "sign"))
	use \|= PUBKEY_USAGE_SIG;
	else if (!ascii_strcasecmp (s, "encrypt")
	\|\| !ascii_strcasecmp (s, "encr"))
	use \|= PUBKEY_USAGE_ENC;
	else if (!ascii_strcasecmp (s, "auth"))
	use \|= PUBKEY_USAGE_AUTH;
	else if (!ascii_strcasecmp (s, "cert"))
	use \|= PUBKEY_USAGE_CERT;
	else if (!ascii_strcasecmp (s, "renc"))
	use \|= PUBKEY_USAGE_RENC;
	else if (!ascii_strcasecmp (s, "time"))
	use \|= PUBKEY_USAGE_TIME;
	else if (!ascii_strcasecmp (s, "group"))
	use \|= PUBKEY_USAGE_GROUP;
	else
	{
	xfree (tokens);
	return -1; /* error */
	}
	}

	xfree (tokens);
	return use;
	}


	/*
	* Parse the usage parameter and set the keyflags. Returns -1 on
	* error, 0 for no usage given or 1 for usage available.
	*/
	static int
	parse_parameter_usage (const char *fname,
	struct para_data_s *para, enum para_name key)
	{
	struct para_data_s *r = get_parameter( para, key );
	int i;

	if (!r)
	return 0; /* none (this is an optional parameter)*/

	i = parse_usagestr (r->u.value);
	if (i == -1)
	{
	log_error ("%s:%d: invalid usage list\n", fname, r->lnr );
	return -1; /* error */
	}

	r->u.usage = i;
	return 1;
	}


	/* Parse the revocation key specified by NAME, check that the public
	* key exists (so that we can get the required public key algorithm),
	* and return a parameter with the revocation key information. On
	* error print a diagnostic and return NULL. */
	static struct para_data_s *
	prepare_desig_revoker (ctrl_t ctrl, const char *name)
	{
	gpg_error_t err;
	struct para_data_s *para = NULL;
	KEYDB_SEARCH_DESC desc;
	int sensitive = 0;
	struct revocation_key revkey;
	PKT_public_key *revoker_pk = NULL;
	size_t fprlen;

	if (!ascii_strncasecmp (name, "sensitive:", 10) && !spacep (name+10))
	{
	name += 10;
	sensitive = 1;
	}

	if (classify_user_id (name, &desc, 1)
	\|\| desc.mode != KEYDB_SEARCH_MODE_FPR)
	{
	log_info (_("\"%s\" is not a fingerprint\n"), name);
	err = gpg_error (GPG_ERR_INV_NAME);
	goto leave;
	}

	revoker_pk = xcalloc (1, sizeof *revoker_pk);
	revoker_pk->req_usage = PUBKEY_USAGE_CERT;
	err = get_pubkey_byname (ctrl, GET_PUBKEY_TRY_LDAP,
	NULL, revoker_pk, name, NULL, NULL, 1);
	if (err)
	goto leave;

	fingerprint_from_pk (revoker_pk, revkey.fpr, &fprlen);
	if (fprlen != 20 && fprlen != 32)
	{
	log_info (_("cannot appoint a PGP 2.x style key as a "
	"designated revoker\n"));
	err = gpg_error (GPG_ERR_UNUSABLE_PUBKEY);
	goto leave;
	}
	revkey.fprlen = fprlen;
	revkey.class = 0x80;
	if (sensitive)
	revkey.class \|= 0x40;
	revkey.algid = revoker_pk->pubkey_algo;

	para = xcalloc (1, sizeof *para);
	para->key = pREVOKER;
	memcpy (&para->u.revkey, &revkey, sizeof revkey);

	leave:
	if (err)
	log_error ("invalid revocation key '%s': %s\n", name, gpg_strerror (err));
	free_public_key (revoker_pk);
	return para;
	}


	/* Parse an ADSK specified by NAME, check that the public key exists
	* and return a parameter with the adsk information. On error print a
	* diagnostic and return NULL. */
	static struct para_data_s *
	prepare_adsk (ctrl_t ctrl, const char *name)
	{
	gpg_error_t err;
	char *namebuffer = NULL;
	struct para_data_s *para = NULL;
	KEYDB_SEARCH_DESC desc;
	PKT_public_key *adsk_pk = NULL;
	char *p;

	if (classify_user_id (name, &desc, 1)
	\|\| desc.mode != KEYDB_SEARCH_MODE_FPR)
	{
	log_info (_("\"%s\" is not a fingerprint\n"), name);
	err = gpg_error (GPG_ERR_INV_NAME);
	goto leave;
	}

	/* Force searching for that exact fingerprint. */
	if (!strchr (name, '!'))
	{
	namebuffer = xstrconcat (name, "!", NULL);
	name = namebuffer;
	}

	adsk_pk = xcalloc (1, sizeof *adsk_pk);
	adsk_pk->req_usage = PUBKEY_USAGE_ENC \| PUBKEY_USAGE_RENC;
	err = get_pubkey_byname (ctrl, GET_PUBKEY_TRY_LDAP,
	NULL, adsk_pk, name, NULL, NULL, 1);
	if (err)
	goto leave;

	para = xcalloc (1, sizeof *para);
	para->key = pADSK;
	para->u.adsk = adsk_pk;
	adsk_pk = NULL;

	leave:
	if (err)
	{
	if (namebuffer && (p=strchr (namebuffer, '!')))
	p = 0; / Strip the ! for the diagnostic. */
	write_status_error ("add_adsk", err);
	log_error ("invalid ADSK '%s' specified: %s\n", name, gpg_strerror (err));
	}
	free_public_key (adsk_pk);
	xfree (namebuffer);
	return para;
	}


	/* Parse a pREVOKER parameter into its dedicated parts. */
	static int
	parse_revocation_key (const char *fname,
	struct para_data_s *para, enum para_name key)
	{
	struct para_data_s *r = get_parameter( para, key );
	struct revocation_key revkey;
	char *pn;
	int i;

	if( !r )
	return 0; /* none (this is an optional parameter) */

	pn = r->u.value;

	revkey.class=0x80;
	revkey.algid=atoi(pn);
	if(!revkey.algid)
	goto fail;

	/* Skip to the fpr */
	while(pn && pn!=':')
	pn++;

	if(*pn!=':')
	goto fail;

	pn++;

	for(i=0;i<MAX_FINGERPRINT_LEN && *pn && !spacep (pn);i++,pn+=2)
	{
	int c=hextobyte(pn);
	if(c==-1)
	goto fail;

	revkey.fpr[i]=c;
	}
	if (i != 20 && i != 32)
	goto fail;

	revkey.fprlen = i;

	/* skip to the tag */
	while(pn && pn!='s' && *pn!='S')
	pn++;

	if(ascii_strcasecmp(pn,"sensitive")==0)
	revkey.class\|=0x40;

	memcpy(&r->u.revkey,&revkey,sizeof(struct revocation_key));

	return 0;

	fail:
	log_error("%s:%d: invalid revocation key\n", fname, r->lnr );
	return -1; /* error */
	}


	static u32
	get_parameter_u32( struct para_data_s *para, enum para_name key )
	{
	struct para_data_s *r = get_parameter( para, key );

	if( !r )
	return 0;
	if (r->key == pKEYCREATIONDATE \|\| r->key == pSUBKEYCREATIONDATE
	\|\| r->key == pAUTHKEYCREATIONDATE)
	return r->u.creation;
	if( r->key == pKEYEXPIRE \|\| r->key == pSUBKEYEXPIRE )
	return r->u.expire;
	if( r->key == pKEYUSAGE \|\| r->key == pSUBKEYUSAGE )
	return r->u.usage;

	return (unsigned int)strtoul( r->u.value, NULL, 10 );
	}

	static unsigned int
	get_parameter_uint( struct para_data_s *para, enum para_name key )
	{
	return get_parameter_u32( para, key );
	}

	static struct revocation_key *
	get_parameter_revkey (struct para_data_s *para, unsigned int idx)
	{
	struct para_data_s *r = get_parameter_idx (para, pREVOKER, idx);
	return r? &r->u.revkey : NULL;
	}

	static PKT_public_key *
	get_parameter_adsk (struct para_data_s *para, unsigned int idx)
	{
	struct para_data_s *r = get_parameter_idx (para, pADSK, idx);
	return r? r->u.adsk : NULL;
	}

	static int
	get_parameter_bool (struct para_data_s *para, enum para_name key)
	{
	struct para_data_s *r = get_parameter (para, key);
	return (r && r->u.abool);
	}


	static int
	proc_parameter_file (ctrl_t ctrl, struct para_data_s para, const char fname,
	struct output_control_s *outctrl, int card )
	{
	struct para_data_s *r;
	const char s1, s2, *s3;
	size_t n;
	char *p;
	strlist_t sl;
	int is_default = 0;
	int have_user_id = 0;
	int err, algo;
	u32 creation_time = (u32)-1;

	/* Check that we have all required parameters. */
	r = get_parameter( para, pKEYTYPE );
	if(r)
	{
	algo = get_parameter_algo (ctrl, para, pKEYTYPE, &is_default);
	if (openpgp_pk_test_algo2 (algo, PUBKEY_USAGE_SIG))
	{
	log_error ("%s:%d: invalid algorithm\n", fname, r->lnr );
	return -1;
	}
	}
	else
	{
	log_error ("%s: no Key-Type specified\n",fname);
	return -1;
	}

	err = parse_parameter_usage (fname, para, pKEYUSAGE);
	if (!err)
	{
	/* Default to algo capabilities if key-usage is not provided and
	no default algorithm has been requested. */
	r = xmalloc_clear(sizeof(*r));
	r->key = pKEYUSAGE;
	r->u.usage = (is_default
	? (PUBKEY_USAGE_CERT \| PUBKEY_USAGE_SIG)
	: openpgp_pk_algo_usage(algo));
	append_to_parameter (para, r);
	}
	else if (err == -1)
	return -1;
	else
	{
	r = get_parameter (para, pKEYUSAGE);
	if (r && (r->u.usage
	& ~(openpgp_pk_algo_usage (algo) \| PUBKEY_USAGE_GROUP)))
	{
	log_error ("%s:%d: specified Key-Usage not allowed for algo %d\n",
	fname, r->lnr, algo);
	return -1;
	}
	}

	is_default = 0;
	r = get_parameter( para, pSUBKEYTYPE );
	if(r)
	{
	algo = get_parameter_algo (ctrl, para, pSUBKEYTYPE, &is_default);
	if (openpgp_pk_test_algo (algo))
	{
	log_error ("%s:%d: invalid algorithm\n", fname, r->lnr );
	return -1;
	}

	err = parse_parameter_usage (fname, para, pSUBKEYUSAGE);
	if (!err)
	{
	/* Default to algo capabilities if subkey-usage is not
	provided. Take care not to include RENC. */
	r = xmalloc_clear (sizeof(*r));
	r->key = pSUBKEYUSAGE;
	r->u.usage = (is_default
	? PUBKEY_USAGE_ENC
	: (openpgp_pk_algo_usage (algo)
	& ~PUBKEY_USAGE_RENC) );
	append_to_parameter (para, r);
	}
	else if (err == -1)
	return -1;
	else
	{
	r = get_parameter (para, pSUBKEYUSAGE);
	if (r && (r->u.usage
	& ~(openpgp_pk_algo_usage (algo)\|PUBKEY_USAGE_GROUP)))
	{
	log_error ("%s:%d: specified Subkey-Usage not allowed"
	" for algo %d\n", fname, r->lnr, algo);
	return -1;
	}
	}
	}


	if( get_parameter_value( para, pUSERID ) )
	have_user_id=1;
	else
	{
	/* create the formatted user ID */
	s1 = get_parameter_value( para, pNAMEREAL );
	s2 = get_parameter_value( para, pNAMECOMMENT );
	s3 = get_parameter_value( para, pNAMEEMAIL );
	if( s1 \|\| s2 \|\| s3 )
	{
	n = (s1?strlen(s1):0) + (s2?strlen(s2):0) + (s3?strlen(s3):0);
	r = xmalloc_clear( sizeof *r + n + 20 );
	r->key = pUSERID;
	p = r->u.value;
	if( s1 )
	p = stpcpy(p, s1 );
	if( s2 )
	p = stpcpy(stpcpy(stpcpy(p," ("), s2 ),")");
	if( s3 )
	{
	/* If we have only the email part, do not add the space
	* and the angle brackets. */
	if (*r->u.value)
	p = stpcpy(stpcpy(stpcpy(p," <"), s3 ),">");
	else
	p = stpcpy (p, s3);
	}
	append_to_parameter (para, r);
	have_user_id=1;
	}
	}

	if(!have_user_id)
	{
	log_error("%s: no User-ID specified\n",fname);
	return -1;
	}

	/* Set preferences, if any. */
	keygen_set_std_prefs(get_parameter_value( para, pPREFERENCES ), 0);

	/* Set keyserver, if any. */
	s1=get_parameter_value( para, pKEYSERVER );
	if(s1)
	{
	struct keyserver_spec *spec;

	spec = parse_keyserver_uri (s1, 1);
	if(spec)
	{
	free_keyserver_spec(spec);
	opt.def_keyserver_url=s1;
	}
	else
	{
	r = get_parameter (para, pKEYSERVER);
	log_error("%s:%d: invalid keyserver url\n", fname, r->lnr );
	return -1;
	}
	}

	/* Set revoker from parameter file, if any. Must be done first so
	* that we don't find a parameter set via prepare_desig_revoker. */
	if (parse_revocation_key (fname, para, pREVOKER))
	return -1;

	/* Check and append revokers from the config file. */
	for (sl = opt.desig_revokers; sl; sl = sl->next)
	{
	r = prepare_desig_revoker (ctrl, sl->d);
	if (!r)
	return -1;
	append_to_parameter (para, r);
	}


	/* Check and append ADSKs from the config file. While doing this
	* also check for duplicate specifications. In addition we remove
	* an optional '!' suffix for easier comparing; the suffix is anyway
	* re-added later. */
	keygen_prepare_new_key_adsks ();
	for (sl = opt.def_new_key_adsks; sl; sl = sl->next)
	{
	if (!*sl->d)
	continue;

	r = prepare_adsk (ctrl, sl->d);
	if (!r)
	return -1;
	append_to_parameter (para, r);
	}


	/* Make KEYCREATIONDATE from Creation-Date. We ignore this if the
	* key has been taken from a card and a keycreationtime has already
	* been set. This is so that we don't generate a key with a
	* fingerprint different from the one stored on the OpenPGP card. */
	r = get_parameter (para, pCREATIONDATE);
	if (r && *r->u.value && !(get_parameter_bool (para, pCARDKEY)
	&& get_parameter_u32 (para, pKEYCREATIONDATE)))
	{
	creation_time = parse_creation_string (r->u.value);
	if (!creation_time)
	{
	log_error ("%s:%d: invalid creation date\n", fname, r->lnr );
	return -1;
	}
	r->u.creation = creation_time;
	r->key = pKEYCREATIONDATE; /* Change that entry. */
	}

	/* Make KEYEXPIRE from Expire-Date. */
	r = get_parameter( para, pEXPIREDATE );
	if( r && *r->u.value )
	{
	u32 seconds;

	seconds = parse_expire_string_with_ct (r->u.value, creation_time);
	if( seconds == (u32)-1 )
	{
	log_error("%s:%d: invalid expire date\n", fname, r->lnr );
	return -1;
	}
	r->u.expire = seconds;
	r->key = pKEYEXPIRE; /* change that entry */

	/* Make SUBKEYEXPIRE from Subkey-Expire-Date, if any. */
	r = get_parameter( para, pSUBKEYEXPIREDATE );
	if( r && *r->u.value )
	{
	seconds = parse_expire_string_with_ct (r->u.value, creation_time);
	if( seconds == (u32)-1 )
	{
	log_error("%s:%d: invalid subkey expire date\n", fname, r->lnr );
	return -1;
	}
	r->key = pSUBKEYEXPIRE; /* change that entry */
	r->u.expire = seconds;
	}
	else
	{
	/* Or else, set Expire-Date for the subkey */
	r = xmalloc_clear( sizeof *r + 20 );
	r->key = pSUBKEYEXPIRE;
	r->u.expire = seconds;
	append_to_parameter (para, r);
	}
	}

	do_generate_keypair (ctrl, para, outctrl, card );
	return 0;
	}


	/****************
	* Kludge to allow non interactive key generation controlled
	* by a parameter file.
	* Note, that string parameters are expected to be in UTF-8
	*/
	static void
	read_parameter_file (ctrl_t ctrl, const char *fname )
	{
	static struct { const char *name;
	enum para_name key;
	} keywords[] = {
	{ "Key-Type", pKEYTYPE},
	{ "Key-Length", pKEYLENGTH },
	{ "Key-Curve", pKEYCURVE },
	{ "Key-Usage", pKEYUSAGE },
	{ "Subkey-Type", pSUBKEYTYPE },
	{ "Subkey-Length", pSUBKEYLENGTH },
	{ "Subkey-Curve", pSUBKEYCURVE },
	{ "Subkey-Usage", pSUBKEYUSAGE },
	{ "Name-Real", pNAMEREAL },
	{ "Name-Email", pNAMEEMAIL },
	{ "Name-Comment", pNAMECOMMENT },
	{ "User-Id", pUSERID },
	{ "Expire-Date", pEXPIREDATE },
	{ "Subkey-Expire-Date", pSUBKEYEXPIREDATE },
	{ "Creation-Date", pCREATIONDATE },
	{ "Passphrase", pPASSPHRASE },
	{ "Preferences", pPREFERENCES },
	{ "Revoker", pREVOKER },
	{ "Handle", pHANDLE },
	{ "Keyserver", pKEYSERVER },
	{ "Keygrip", pKEYGRIP },
	{ "Key-Grip", pKEYGRIP },
	{ "Subkey-grip", pSUBKEYGRIP },
	{ "Key-Version", pVERSION },
	{ "Subkey-Version", pSUBVERSION },
	{ NULL, 0 }
	};
	IOBUF fp;
	byte *line;
	unsigned int maxlen, nline;
	char *p;
	int lnr;
	const char *err = NULL;
	struct para_data_s para, r;
	int i;
	struct output_control_s outctrl;

	memset( &outctrl, 0, sizeof( outctrl ) );
	outctrl.pub.afx = new_armor_context ();

	if( !fname \|\| !*fname)
	fname = "-";

	fp = iobuf_open (fname);
	if (fp && is_secured_file (iobuf_get_fd (fp)))
	{
	iobuf_close (fp);
	fp = NULL;
	gpg_err_set_errno (EPERM);
	}
	if (!fp) {
	log_error (_("can't open '%s': %s\n"), fname, strerror(errno) );
	return;
	}
	iobuf_ioctl (fp, IOBUF_IOCTL_NO_CACHE, 1, NULL);

	lnr = 0;
	err = NULL;
	para = NULL;
	maxlen = 1024;
	line = NULL;
	nline = 0;
	while ( iobuf_read_line (fp, &line, &nline, &maxlen) ) {
	char keyword, value;

	lnr++;
	if( !maxlen ) {
	err = "line too long";
	break;
	}
	for( p = line; isspace((byte)p); p++ )
	;
	if( !p \|\| p == '#' )
	continue;
	keyword = p;
	if( *keyword == '%' ) {
	for( ; !isspace((byte)p); p++ )
	;
	if( *p )
	*p++ = 0;
	for( ; isspace((byte)p); p++ )
	;
	value = p;
	trim_trailing_ws( value, strlen(value) );
	if( !ascii_strcasecmp( keyword, "%echo" ) )
	log_info("%s\n", value );
	else if( !ascii_strcasecmp( keyword, "%dry-run" ) )
	outctrl.dryrun = 1;
	else if( !ascii_strcasecmp( keyword, "%ask-passphrase" ) )
	; /* Dummy for backward compatibility. */
	else if( !ascii_strcasecmp( keyword, "%no-ask-passphrase" ) )
	; /* Dummy for backward compatibility. */
	else if( !ascii_strcasecmp( keyword, "%no-protection" ) )
	outctrl.keygen_flags \|= KEYGEN_FLAG_NO_PROTECTION;
	else if( !ascii_strcasecmp( keyword, "%transient-key" ) )
	outctrl.keygen_flags \|= KEYGEN_FLAG_TRANSIENT_KEY;
	else if( !ascii_strcasecmp( keyword, "%commit" ) ) {
	outctrl.lnr = lnr;
	if (proc_parameter_file (ctrl, para, fname, &outctrl, 0 ))
	print_status_key_not_created
	(get_parameter_value (para, pHANDLE));
	release_parameter_list( para );
	para = NULL;
	}
	else if( !ascii_strcasecmp( keyword, "%pubring" ) ) {
	if( outctrl.pub.fname && !strcmp( outctrl.pub.fname, value ) )
	; /* still the same file - ignore it */
	else {
	xfree( outctrl.pub.newfname );
	outctrl.pub.newfname = xstrdup( value );
	outctrl.use_files = 1;
	}
	}
	else if( !ascii_strcasecmp( keyword, "%secring" ) ) {
	/* Ignore this command. */
	}
	else
	log_info("skipping control '%s' (%s)\n", keyword, value );


	continue;
	}


	if( !(p = strchr( p, ':' )) \|\| p == keyword ) {
	err = "missing colon";
	break;
	}
	if( *p )
	*p++ = 0;
	for( ; isspace((byte)p); p++ )
	;
	if( !*p ) {
	err = "missing argument";
	break;
	}
	value = p;
	trim_trailing_ws( value, strlen(value) );

	for(i=0; keywords[i].name; i++ ) {
	if( !ascii_strcasecmp( keywords[i].name, keyword ) )
	break;
	}
	if( !keywords[i].name ) {
	err = "unknown keyword";
	break;
	}
	if( keywords[i].key != pKEYTYPE && !para ) {
	err = "parameter block does not start with \"Key-Type\"";
	break;
	}

	if( keywords[i].key == pKEYTYPE && para ) {
	outctrl.lnr = lnr;
	if (proc_parameter_file (ctrl, para, fname, &outctrl, 0 ))
	print_status_key_not_created
	(get_parameter_value (para, pHANDLE));
	release_parameter_list( para );
	para = NULL;
	}
	else {
	for( r = para; r; r = r->next ) {
	if( r->key == keywords[i].key )
	break;
	}
	if( r ) {
	err = "duplicate keyword";
	break;
	}
	}

	if ((keywords[i].key == pVERSION
	\|\| keywords[i].key == pSUBVERSION))
	; /* Ignore version. */
	else
	{
	r = xmalloc_clear( sizeof *r + strlen( value ) );
	r->lnr = lnr;
	r->key = keywords[i].key;
	strcpy( r->u.value, value );
	r->next = para;
	para = r;
	}
	}
	if( err )
	log_error("%s:%d: %s\n", fname, lnr, err );
	else if( iobuf_error (fp) ) {
	log_error("%s:%d: read error\n", fname, lnr);
	}
	else if( para ) {
	outctrl.lnr = lnr;
	if (proc_parameter_file (ctrl, para, fname, &outctrl, 0 ))
	print_status_key_not_created (get_parameter_value (para, pHANDLE));
	}

	if( outctrl.use_files ) { /* close open streams */
	iobuf_close( outctrl.pub.stream );

	/* Must invalidate that ugly cache to actually close it. */
	if (outctrl.pub.fname)
	iobuf_ioctl (NULL, IOBUF_IOCTL_INVALIDATE_CACHE,
	0, (char*)outctrl.pub.fname);

	xfree( outctrl.pub.fname );
	xfree( outctrl.pub.newfname );
	}

	xfree (line);
	release_parameter_list( para );
	iobuf_close (fp);
	release_armor_context (outctrl.pub.afx);
	}


	/* Helper for quick_generate_keypair. */
	static struct para_data_s *
	quickgen_set_para (struct para_data_s *para, int for_subkey,
	int algo, int nbits, const char *curve, unsigned int use,
	int version, const char *keygrip, u32 keytime)
	{
	struct para_data_s *r;

	r = xmalloc_clear (sizeof *r + 50);
	r->key = for_subkey? pSUBKEYUSAGE : pKEYUSAGE;
	if (use)
	snprintf (r->u.value, 30, "%s%s%s%s%s%s%s",
	(use & PUBKEY_USAGE_ENC)? "encr " : "",
	(use & PUBKEY_USAGE_SIG)? "sign " : "",
	(use & PUBKEY_USAGE_AUTH)? "auth " : "",
	(use & PUBKEY_USAGE_CERT)? "cert " : "",
	(use & PUBKEY_USAGE_RENC)? "renc " : "",
	(use & PUBKEY_USAGE_TIME)? "time " : "",
	(use & PUBKEY_USAGE_GROUP)?"group ": "");
	else
	strcpy (r->u.value, for_subkey ? "encr" : "sign");
	r->next = para;
	para = r;
	r = xmalloc_clear (sizeof *r + 20);
	r->key = for_subkey? pSUBKEYTYPE : pKEYTYPE;
	snprintf (r->u.value, 20, "%d", algo);
	r->next = para;
	para = r;

	if (keygrip)
	{
	r = xmalloc_clear (sizeof *r + strlen (keygrip));
	r->key = for_subkey? pSUBKEYGRIP : pKEYGRIP;
	strcpy (r->u.value, keygrip);
	r->next = para;
	para = r;
	}
	else if (curve)
	{
	r = xmalloc_clear (sizeof *r + strlen (curve));
	r->key = for_subkey? pSUBKEYCURVE : pKEYCURVE;
	strcpy (r->u.value, curve);
	r->next = para;
	para = r;
	}

	/* Always store the size - although not required for ECC it is
	* required for composite algos. Should not harm anyway. */
	r = xmalloc_clear (sizeof *r + 20);
	r->key = for_subkey? pSUBKEYLENGTH : pKEYLENGTH;
	sprintf (r->u.value, "%u", nbits);
	r->next = para;
	para = r;

	r = xmalloc_clear (sizeof *r + 20);
	r->key = for_subkey? pSUBVERSION : pVERSION;
	snprintf (r->u.value, 20, "%d", version);
	r->next = para;
	para = r;

	if (keytime)
	{
	r = xmalloc_clear (sizeof *r);
	r->key = for_subkey? pSUBKEYCREATIONDATE : pKEYCREATIONDATE;
	r->u.creation = keytime;
	r->next = para;
	para = r;

	}

	return para;
	}


	/*
	* Unattended generation of a standard key.
	*/
	void
	quick_generate_keypair (ctrl_t ctrl, const char uid, const char algostr,
	const char usagestr, const char expirestr)
	{
	gpg_error_t err;
	struct para_data_s *para = NULL;
	struct para_data_s *r;
	struct output_control_s outctrl;
	int use_tty;

	memset (&outctrl, 0, sizeof outctrl);

	use_tty = (!opt.batch && !opt.answer_yes
	&& !algostr && !usagestr && !*expirestr
	&& !cpr_enabled ()
	&& gnupg_isatty (fileno (stdin))
	&& gnupg_isatty (fileno (stdout))
	&& gnupg_isatty (fileno (stderr)));

	r = xmalloc_clear (sizeof *r + strlen (uid));
	r->key = pUSERID;
	strcpy (r->u.value, uid);
	r->next = para;
	para = r;

	uid = trim_spaces (r->u.value);
	if (!*uid \|\| (!opt.allow_freeform_uid && !is_valid_user_id (uid)))
	{
	log_error (_("Key generation failed: %s\n"),
	gpg_strerror (GPG_ERR_INV_USER_ID));
	goto leave;
	}

	/* If gpg is directly used on the console ask whether a key with the
	given user id shall really be created. */
	if (use_tty)
	{
	tty_printf (_("About to create a key for:\n \"%s\"\n\n"), uid);
	if (!cpr_get_answer_is_yes_def ("quick_keygen.okay",
	_("Continue? (Y/n) "), 1))
	goto leave;
	}

	/* Check whether such a user ID already exists. */
	{
	KEYDB_HANDLE kdbhd;
	KEYDB_SEARCH_DESC desc;

	memset (&desc, 0, sizeof desc);
	desc.mode = KEYDB_SEARCH_MODE_EXACT;
	desc.u.name = uid;

	kdbhd = keydb_new (ctrl);
	if (!kdbhd)
	goto leave;

	err = keydb_search (kdbhd, &desc, 1, NULL);
	keydb_release (kdbhd);
	if (gpg_err_code (err) != GPG_ERR_NOT_FOUND)
	{
	log_info (_("A key for \"%s\" already exists\n"), uid);
	if (opt.answer_yes)
	;
	else if (!use_tty
	\|\| !cpr_get_answer_is_yes_def ("quick_keygen.force",
	_("Create anyway? (y/N) "), 0))
	{
	write_status_error ("genkey", gpg_error (304));
	log_inc_errorcount (); /* we used log_info */
	goto leave;
	}
	log_info (_("creating anyway\n"));
	}
	}

	if (!*expirestr \|\| strcmp (expirestr, "-") == 0)
	expirestr = default_expiration_interval;

	if ((!*algostr \|\| !ascii_strcasecmp (algostr, "default")
	\|\| !ascii_strcasecmp (algostr, "future-default")
	\|\| !ascii_strcasecmp (algostr, "futuredefault")
	\|\| !ascii_strcasecmp (algostr, "pqc")
	\|\| !ascii_strcasecmp (algostr, "card"))
	&& (!*usagestr \|\| !ascii_strcasecmp (usagestr, "default")
	\|\| !strcmp (usagestr, "-")))
	{
	/* Use default key parameters. */
	int algo, subalgo, version, subversion;
	unsigned int size, subsize;
	unsigned int keyuse, subkeyuse;
	const char curve, subcurve;
	char keygrip, subkeygrip;
	u32 keytime, subkeytime;

	err = parse_key_parameter_string (ctrl, algostr, -1, 0,
	&algo, &size, &keyuse, &curve, &version,
	&keygrip, &keytime,
	&subalgo, &subsize, &subkeyuse,
	&subcurve, &subversion,
	&subkeygrip, &subkeytime);
	if (err)
	{
	log_error (_("Key generation failed: %s\n"), gpg_strerror (err));
	goto leave;
	}

	para = quickgen_set_para (para, 0, algo, size, curve, keyuse, version,
	keygrip, keytime);
	if (subalgo)
	para = quickgen_set_para (para, 1,
	subalgo, subsize, subcurve, subkeyuse,
	subversion, subkeygrip, subkeytime);
	if (*expirestr)
	{
	u32 expire;

	expire = parse_expire_string (expirestr);
	if (expire == (u32)-1 )
	{
	err = gpg_error (GPG_ERR_INV_VALUE);
	log_error (_("Key generation failed: %s\n"), gpg_strerror (err));
	goto leave;
	}
	r = xmalloc_clear (sizeof *r + 20);
	r->key = pKEYEXPIRE;
	r->u.expire = expire;
	r->next = para;
	para = r;
	}

	xfree (keygrip);
	xfree (subkeygrip);
	}
	else
	{
	/* Extended unattended mode. Creates only the primary key. */
	int algo, version;
	unsigned int use;
	u32 expire;
	unsigned int nbits;
	const char *curve;
	char *keygrip;
	u32 keytime;

	err = parse_algo_usage_expire (ctrl, 0, algostr, usagestr, expirestr,
	&algo, &use, &expire, &nbits, &curve,
	&version, &keygrip, &keytime);
	if (err)
	{
	log_error (_("Key generation failed: %s\n"), gpg_strerror (err) );
	goto leave;
	}

	para = quickgen_set_para (para, 0, algo, nbits, curve, use, version,
	keygrip, keytime);
	r = xmalloc_clear (sizeof *r + 20);
	r->key = pKEYEXPIRE;
	r->u.expire = expire;
	r->next = para;
	para = r;

	xfree (keygrip);
	}

	/* If the pinentry loopback mode is not and we have a static
	passphrase (i.e. set with --passphrase{,-fd,-file} while in batch
	mode), we use that passphrase for the new key. */
	if (opt.pinentry_mode != PINENTRY_MODE_LOOPBACK
	&& have_static_passphrase ())
	{
	const char *s = get_static_passphrase ();

	r = xmalloc_clear (sizeof *r + strlen (s));
	r->key = pPASSPHRASE;
	strcpy (r->u.value, s);
	r->next = para;
	para = r;
	}

	if (!ascii_strcasecmp (algostr, "card")
	\|\| !ascii_strncasecmp (algostr, "card/", 5))
	{
	r = xmalloc_clear (sizeof *r);
	r->key = pCARDKEY;
	r->u.abool = 1;
	r->next = para;
	para = r;
	}

	proc_parameter_file (ctrl, para, "[internal]", &outctrl, 0);

	leave:
	release_parameter_list (para);
	}


	/*
	* Generate a keypair (fname is only used in batch mode) If
	* CARD_SERIALNO is not NULL the function will create the keys on an
	* OpenPGP Card. If CARD_BACKUP_KEY has been set and CARD_SERIALNO is
	* NOT NULL, the encryption key for the card is generated on the host,
	* imported to the card and a backup file created by gpg-agent. If
	* FULL is not set only the basic prompts are used (except for batch
	* mode).
	*/
	void
	generate_keypair (ctrl_t ctrl, int full, const char *fname,
	const char *card_serialno, int card_backup_key)
	{
	gpg_error_t err;
	unsigned int nbits;
	char *uid = NULL;
	int algo;
	unsigned int use;
	int both = 0;
	u32 expire;
	struct para_data_s *para = NULL;
	struct para_data_s *r;
	struct output_control_s outctrl;

	#ifndef ENABLE_CARD_SUPPORT
	(void)card_backup_key;
	#endif

	memset( &outctrl, 0, sizeof( outctrl ) );

	if (opt.batch && card_serialno)
	{
	/* We don't yet support unattended key generation with a card
	* serial number. */
	log_error (_("can't do this in batch mode\n"));
	print_further_info ("key generation with card serial number");
	return;
	}

	if (opt.batch)
	{
	read_parameter_file (ctrl, fname);
	return;
	}

	if (card_serialno)
	{
	#ifdef ENABLE_CARD_SUPPORT
	struct agent_card_info_s info;

	memset (&info, 0, sizeof (info));
	err = agent_scd_getattr ("KEY-ATTR", &info);
	if (err)
	{
	log_error (_("error getting current key info: %s\n"),
	gpg_strerror (err));
	return;
	}

	r = xcalloc (1, sizeof *r + strlen (card_serialno) );
	r->key = pSERIALNO;
	strcpy( r->u.value, card_serialno);
	r->next = para;
	para = r;

	r = xcalloc (1, sizeof *r + 20 );
	r->key = pKEYTYPE;
	sprintf( r->u.value, "%d", info.key_attr[0].algo );
	r->next = para;
	para = r;
	r = xcalloc (1, sizeof *r + 20 );
	r->key = pKEYUSAGE;
	strcpy (r->u.value, "sign");
	r->next = para;
	para = r;

	r = xcalloc (1, sizeof *r + 20 );
	r->key = pSUBKEYTYPE;
	sprintf( r->u.value, "%d", info.key_attr[1].algo );
	r->next = para;
	para = r;
	r = xcalloc (1, sizeof *r + 20 );
	r->key = pSUBKEYUSAGE;
	strcpy (r->u.value, "encrypt");
	r->next = para;
	para = r;
	if (info.key_attr[1].algo == PUBKEY_ALGO_RSA)
	{
	r = xcalloc (1, sizeof *r + 20 );
	r->key = pSUBKEYLENGTH;
	sprintf( r->u.value, "%u", info.key_attr[1].nbits);
	r->next = para;
	para = r;
	}
	else if (info.key_attr[1].algo == PUBKEY_ALGO_ECDSA
	\|\| info.key_attr[1].algo == PUBKEY_ALGO_EDDSA
	\|\| info.key_attr[1].algo == PUBKEY_ALGO_ECDH)
	{
	r = xcalloc (1, sizeof *r + strlen (info.key_attr[1].curve));
	r->key = pSUBKEYCURVE;
	strcpy (r->u.value, info.key_attr[1].curve);
	r->next = para;
	para = r;
	}

	r = xcalloc (1, sizeof *r + 20 );
	r->key = pAUTHKEYTYPE;
	sprintf( r->u.value, "%d", info.key_attr[2].algo );
	r->next = para;
	para = r;

	if (card_backup_key)
	{
	r = xcalloc (1, sizeof *r + 1);
	r->key = pCARDBACKUPKEY;
	strcpy (r->u.value, "1");
	r->next = para;
	para = r;
	}
	#endif /ENABLE_CARD_SUPPORT/
	}
	else if (full) /* Full featured key generation. */
	{
	int subkey_algo;
	char *key_from_hexgrip = NULL;
	int cardkey;
	u32 keytime;

	algo = ask_algo (ctrl, 0, &subkey_algo, &use,
	&key_from_hexgrip, &cardkey, &keytime);
	if (key_from_hexgrip)
	{
	r = xmalloc_clear( sizeof *r + 20 );
	r->key = pKEYTYPE;
	sprintf( r->u.value, "%d", algo);
	r->next = para;
	para = r;

	if (use)
	{
	r = xmalloc_clear( sizeof *r + 25 );
	r->key = pKEYUSAGE;
	sprintf( r->u.value, "%s%s%s",
	(use & PUBKEY_USAGE_SIG)? "sign ":"",
	(use & PUBKEY_USAGE_ENC)? "encrypt ":"",
	(use & PUBKEY_USAGE_AUTH)? "auth":"" );
	r->next = para;
	para = r;
	}

	r = xmalloc_clear( sizeof *r + 40 );
	r->key = pKEYGRIP;
	strcpy (r->u.value, key_from_hexgrip);
	r->next = para;
	para = r;

	r = xmalloc_clear (sizeof *r);
	r->key = pCARDKEY;
	r->u.abool = cardkey;
	r->next = para;
	para = r;

	if (cardkey)
	{
	r = xmalloc_clear (sizeof *r);
	r->key = pKEYCREATIONDATE;
	r->u.creation = keytime;
	r->next = para;
	para = r;
	}

	xfree (key_from_hexgrip);
	}
	else
	{
	const char *curve = NULL;

	if (algo == PUBKEY_ALGO_ECDSA && subkey_algo == PUBKEY_ALGO_KYBER)
	{
	/* Create primary and subkey at once. */
	const char *subalgostr;
	const char *s;
	const char *pricurve;
	int prialgo = PUBKEY_ALGO_ECDSA;

	both = 1;
	subalgostr = ask_kyber_variant ();
	if (!subalgostr) /* Should not happen. */
	subalgostr = PQC_STD_KEY_PARAM_SUB;

	/* Determine the primary key algo from the subkey algo. */
	if (strstr (subalgostr, "bp384"))
	pricurve = "brainpoolP384r1";
	else if (strstr (subalgostr, "bp256"))
	pricurve = "brainpoolP256r1";
	else if (strstr (subalgostr, "cv448"))
	{
	pricurve = "Ed448";
	prialgo = PUBKEY_ALGO_EDDSA;
	}
	else
	{
	pricurve = "Ed25519";
	prialgo = PUBKEY_ALGO_EDDSA;
	}

	r = xmalloc_clear (sizeof *r + 20);
	r->key = pKEYTYPE;
	sprintf (r->u.value, "%d", prialgo);
	r->next = para;
	para = r;

	r = xmalloc_clear (sizeof *r + strlen (pricurve));
	r->key = pKEYCURVE;
	strcpy (r->u.value, pricurve);
	r->next = para;
	para = r;

	r = xmalloc_clear (sizeof *r + 20);
	r->key = pKEYUSAGE;
	strcpy (r->u.value, "sign");
	r->next = para;
	para = r;

	r = xmalloc_clear (sizeof *r + 20);
	r->key = pSUBKEYTYPE;
	sprintf (r->u.value, "%d", PUBKEY_ALGO_KYBER);
	r->next = para;
	para = r;

	r = xmalloc_clear (sizeof *r + 20);
	r->key = pSUBKEYLENGTH;
	sprintf (r->u.value, "%u",
	strstr (subalgostr, "768_")? 768 : 1024);
	r->next = para;
	para = r;

	s = strchr (subalgostr, '_');
	log_assert (s && s[1]);
	s++;
	r = xmalloc_clear (sizeof *r + strlen (s));
	r->key = pSUBKEYCURVE;
	strcpy (r->u.value, s);
	r->next = para;
	para = r;

	r = xmalloc_clear (sizeof *r + 20);
	r->key = pSUBKEYUSAGE;
	strcpy( r->u.value, "encrypt" );
	r->next = para;
	para = r;
	}
	else if (subkey_algo)
	{
	/* Create primary and subkey at once. */
	both = 1;
	if (algo == PUBKEY_ALGO_ECDSA
	\|\| algo == PUBKEY_ALGO_EDDSA
	\|\| algo == PUBKEY_ALGO_ECDH)
	{
	curve = ask_curve (&algo, &subkey_algo, NULL);
	r = xmalloc_clear( sizeof *r + 20 );
	r->key = pKEYTYPE;
	sprintf( r->u.value, "%d", algo);
	r->next = para;
	para = r;
	nbits = 0;
	r = xmalloc_clear (sizeof *r + strlen (curve));
	r->key = pKEYCURVE;
	strcpy (r->u.value, curve);
	r->next = para;
	para = r;
	if (!strcmp (curve, "X448") \|\| !strcmp (curve, "Ed448"))
	{
	r = xmalloc_clear (sizeof *r + 20);
	r->key = pVERSION;
	snprintf (r->u.value, 20, "%d", 5);
	r->next = para;
	para = r;
	}
	}
	else
	{
	r = xmalloc_clear( sizeof *r + 20 );
	r->key = pKEYTYPE;
	sprintf( r->u.value, "%d", algo);
	r->next = para;
	para = r;
	nbits = ask_keysize (algo, 0);
	r = xmalloc_clear( sizeof *r + 20 );
	r->key = pKEYLENGTH;
	sprintf( r->u.value, "%u", nbits);
	r->next = para;
	para = r;
	}
	r = xmalloc_clear( sizeof *r + 20 );
	r->key = pKEYUSAGE;
	strcpy( r->u.value, "sign" );
	r->next = para;
	para = r;

	r = xmalloc_clear( sizeof *r + 20 );
	r->key = pSUBKEYTYPE;
	sprintf( r->u.value, "%d", subkey_algo);
	r->next = para;
	para = r;
	r = xmalloc_clear( sizeof *r + 20 );
	r->key = pSUBKEYUSAGE;
	strcpy( r->u.value, "encrypt" );
	r->next = para;
	para = r;

	if (algo == PUBKEY_ALGO_ECDSA
	\|\| algo == PUBKEY_ALGO_EDDSA
	\|\| algo == PUBKEY_ALGO_ECDH)
	{
	if (algo == PUBKEY_ALGO_EDDSA
	&& subkey_algo == PUBKEY_ALGO_ECDH)
	{
	/* Need to switch to a different curve for the
	encryption key. */
	if (!strcmp (curve, "Ed25519"))
	curve = "Curve25519";
	else
	{
	curve = "X448";
	r = xmalloc_clear (sizeof *r + 20);
	r->key = pSUBVERSION;
	snprintf (r->u.value, 20, "%d", 5);
	r->next = para;
	para = r;
	}
	}
	r = xmalloc_clear (sizeof *r + strlen (curve));
	r->key = pSUBKEYCURVE;
	strcpy (r->u.value, curve);
	r->next = para;
	para = r;
	}
	}
	else /* Create only a single key. */
	{
	/* For ECC we need to ask for the curve before storing the
	algo because ask_curve may change the algo. */
	if (algo == PUBKEY_ALGO_ECDSA
	\|\| algo == PUBKEY_ALGO_EDDSA
	\|\| algo == PUBKEY_ALGO_ECDH)
	{
	curve = ask_curve (&algo, NULL, NULL);
	r = xmalloc_clear (sizeof *r + strlen (curve));
	r->key = pKEYCURVE;
	strcpy (r->u.value, curve);
	r->next = para;
	para = r;
	if (!strcmp (curve, "X448") \|\| !strcmp (curve, "Ed448"))
	{
	r = xmalloc_clear (sizeof *r + 20);
	r->key = pVERSION;
	snprintf (r->u.value, 20, "%d", 5);
	r->next = para;
	para = r;
	}
	}

	r = xmalloc_clear( sizeof *r + 20 );
	r->key = pKEYTYPE;
	sprintf( r->u.value, "%d", algo );
	r->next = para;
	para = r;

	if (use)
	{
	r = xmalloc_clear( sizeof *r + 25 );
	r->key = pKEYUSAGE;
	sprintf( r->u.value, "%s%s%s",
	(use & PUBKEY_USAGE_SIG)? "sign ":"",
	(use & PUBKEY_USAGE_ENC)? "encrypt ":"",
	(use & PUBKEY_USAGE_AUTH)? "auth":"" );
	r->next = para;
	para = r;
	}
	nbits = 0;
	}

	if (algo == PUBKEY_ALGO_ECDSA
	\|\| algo == PUBKEY_ALGO_EDDSA
	\|\| algo == PUBKEY_ALGO_ECDH)
	{
	/* The curve has already been set. */
	}
	else
	{
	nbits = ask_keysize (both? subkey_algo : algo, nbits);
	r = xmalloc_clear( sizeof *r + 20 );
	r->key = both? pSUBKEYLENGTH : pKEYLENGTH;
	sprintf( r->u.value, "%u", nbits);
	r->next = para;
	para = r;
	}
	}
	}
	else /* Default key generation. */
	{
	int subalgo, version, subversion;
	unsigned int size, subsize;
	unsigned int keyuse, subkeyuse;
	const char curve, subcurve;
	char keygrip, subkeygrip;
	u32 keytime, subkeytime;

	tty_printf ( _("Note: Use \"%s %s\""
	" for a full featured key generation dialog.\n"),
	GPG_NAME
	, "--full-generate-key" );

	err = parse_key_parameter_string (ctrl, NULL, -1, 0,
	&algo, &size, &keyuse, &curve, &version,
	&keygrip, &keytime,
	&subalgo, &subsize,
	&subkeyuse, &subcurve, &subversion,
	&subkeygrip, &subkeytime);
	if (err)
	{
	log_error (_("Key generation failed: %s\n"), gpg_strerror (err));
	return;
	}
	para = quickgen_set_para (para, 0,
	algo, size, curve, keyuse,
	version, keygrip, keytime);
	if (subalgo)
	para = quickgen_set_para (para, 1,
	subalgo, subsize, subcurve, subkeyuse,
	subversion, subkeygrip, subkeytime);

	xfree (keygrip);
	xfree (subkeygrip);
	}


	expire = full? ask_expire_interval (0, NULL)
	: parse_expire_string (default_expiration_interval);
	r = xcalloc (1, sizeof *r + 20);
	r->key = pKEYEXPIRE;
	r->u.expire = expire;
	r->next = para;
	para = r;
	r = xcalloc (1, sizeof *r + 20);
	r->key = pSUBKEYEXPIRE;
	r->u.expire = expire;
	r->next = para;
	para = r;

	uid = ask_user_id (0, full, NULL);
	if (!uid)
	{
	log_error(_("Key generation canceled.\n"));
	release_parameter_list( para );
	return;
	}
	r = xcalloc (1, sizeof *r + strlen (uid));
	r->key = pUSERID;
	strcpy (r->u.value, uid);
	r->next = para;
	para = r;

	proc_parameter_file (ctrl, para, "[internal]", &outctrl, !!card_serialno);
	release_parameter_list (para);
	}


	/* Create and delete a dummy packet to start off a list of kbnodes. */
	static void
	start_tree(KBNODE *tree)
	{
	PACKET *pkt;

	pkt=xmalloc_clear(sizeof(*pkt));
	pkt->pkttype=PKT_NONE;
	*tree=new_kbnode(pkt);
	delete_kbnode(*tree);
	}


	/* Write the protected secret key to the file. */
	static gpg_error_t
	card_write_key_to_backup_file (PKT_public_key sk, const char backup_dir)
	{
	gpg_error_t err = 0;
	char keyid_buffer[2 * 8 + 1];
	char name_buffer[50];
	char *fname;
	IOBUF fp;
	mode_t oldmask;
	PACKET *pkt = NULL;

	format_keyid (pk_keyid (sk), KF_LONG, keyid_buffer, sizeof (keyid_buffer));
	snprintf (name_buffer, sizeof name_buffer, "sk_%s.gpg", keyid_buffer);

	fname = make_filename (backup_dir, name_buffer, NULL);
	/* Note that the umask call is not anymore needed because
	iobuf_create now takes care of it. However, it does not harm
	and thus we keep it. */
	oldmask = umask (077);
	if (is_secured_filename (fname))
	{
	fp = NULL;
	gpg_err_set_errno (EPERM);
	}
	else
	fp = iobuf_create (fname, 1);
	umask (oldmask);
	if (!fp)
	{
	err = gpg_error_from_syserror ();
	log_error (_("can't create backup file '%s': %s\n"), fname, strerror (errno) );
	goto leave;
	}

	pkt = xcalloc (1, sizeof *pkt);
	pkt->pkttype = PKT_SECRET_KEY;
	pkt->pkt.secret_key = sk;

	err = build_packet (fp, pkt);
	if (err)
	{
	log_error ("build packet failed: %s\n", gpg_strerror (err));
	iobuf_cancel (fp);
	}
	else
	{
	char *fprbuf;

	iobuf_close (fp);
	iobuf_ioctl (NULL, IOBUF_IOCTL_INVALIDATE_CACHE, 0, (char*)fname);
	log_info (_("Note: backup of card key saved to '%s'\n"), fname);

	fprbuf = hexfingerprint (sk, NULL, 0);
	if (!fprbuf)
	{
	err = gpg_error_from_syserror ();
	goto leave;
	}
	write_status_text_and_buffer (STATUS_BACKUP_KEY_CREATED, fprbuf,
	fname, strlen (fname), 0);
	xfree (fprbuf);
	}

	leave:
	xfree (pkt);
	xfree (fname);
	return err;
	}


	/* Store key to card and make a backup file in OpenPGP format. */
	static gpg_error_t
	card_store_key_with_backup (ctrl_t ctrl, PKT_public_key *sub_psk,
	const char *backup_dir)
	{
	gpg_error_t err;
	PKT_public_key *sk;
	gnupg_isotime_t timestamp;
	char *hexgrip = NULL;
	struct agent_card_info_s info;
	gcry_cipher_hd_t cipherhd = NULL;
	char *cache_nonce = NULL;
	void *kek = NULL;
	size_t keklen;
	char *ecdh_param_str = NULL;
	int key_is_on_card = 0;

	memset (&info, 0, sizeof (info));

	sk = copy_public_key (NULL, sub_psk);
	if (!sk)
	{
	err = gpg_error_from_syserror ();
	goto leave;
	}

	epoch2isotime (timestamp, (time_t)sk->timestamp);
	if (sk->pubkey_algo == PUBKEY_ALGO_ECDH)
	{
	ecdh_param_str = ecdh_param_str_from_pk (sk);
	if (!ecdh_param_str)
	{
	err = gpg_error_from_syserror ();
	goto leave;
	}
	}

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

	err = agent_scd_getattr ("SERIALNO", &info);
	if (err)
	goto leave;

	err = agent_keytocard (hexgrip, 2, 1, info.serialno,
	timestamp, ecdh_param_str);
	if (err)
	goto leave;

	key_is_on_card = 1;
	err = agent_keywrap_key (ctrl, 1, &kek, &keklen);
	if (err)
	{
	log_error ("error getting the KEK: %s\n", gpg_strerror (err));
	goto leave;
	}

	err = gcry_cipher_open (&cipherhd, GCRY_CIPHER_AES128,
	GCRY_CIPHER_MODE_AESWRAP, 0);
	if (!err)
	err = gcry_cipher_setkey (cipherhd, kek, keklen);
	if (err)
	{
	log_error ("error setting up an encryption context: %s\n",
	gpg_strerror (err));
	goto leave;
	}

	err = receive_seckey_from_agent (ctrl, cipherhd, 0, 0,
	&cache_nonce, hexgrip, sk, NULL);
	if (err)
	{
	log_error ("error getting secret key from agent: %s\n",
	gpg_strerror (err));
	goto leave;
	}

	err = card_write_key_to_backup_file (sk, backup_dir);
	if (err)
	log_error ("writing card key to backup file: %s\n", gpg_strerror (err));
	else
	{
	/* Remove secret key data in agent side. */
	agent_scd_learn (NULL, 1);
	}

	leave:
	if (err && key_is_on_card)
	{
	tty_printf (_(
	"Warning: Although the key has been written to the card, a backup file was\n"
	" not properly written to the disk. You may want to repeat the\n"
	" entire operation or just create a new encryption key on the card.\n"
	));
	}

	xfree (info.serialno);
	xfree (ecdh_param_str);
	xfree (cache_nonce);
	gcry_cipher_close (cipherhd);
	xfree (kek);
	xfree (hexgrip);
	free_public_key (sk);
	return err;
	}


	static void
	do_generate_keypair (ctrl_t ctrl, struct para_data_s *para,
	struct output_control_s *outctrl, int card)
	{
	gpg_error_t err;
	KBNODE pub_root = NULL;
	const char *s;
	PKT_public_key *pri_psk = NULL;
	PKT_public_key *sub_psk = NULL;
	struct revocation_key *revkey;
	int did_sub = 0;
	u32 keytimestamp, subkeytimestamp, authkeytimestamp, signtimestamp;
	char *cache_nonce = NULL;
	int algo;
	u32 expire;
	const char *key_from_hexgrip = NULL;
	int cardkey;
	unsigned int keygen_flags;
	unsigned int idx;
	int any_adsk = 0;

	if (outctrl->dryrun)
	{
	log_info("dry-run mode - key generation skipped\n");
	return;
	}

	if ( outctrl->use_files )
	{
	if ( outctrl->pub.newfname )
	{
	iobuf_close(outctrl->pub.stream);
	outctrl->pub.stream = NULL;
	if (outctrl->pub.fname)
	iobuf_ioctl (NULL, IOBUF_IOCTL_INVALIDATE_CACHE,
	0, (char*)outctrl->pub.fname);
	xfree( outctrl->pub.fname );
	outctrl->pub.fname = outctrl->pub.newfname;
	outctrl->pub.newfname = NULL;

	if (is_secured_filename (outctrl->pub.fname) )
	{
	outctrl->pub.stream = NULL;
	gpg_err_set_errno (EPERM);
	}
	else
	outctrl->pub.stream = iobuf_create (outctrl->pub.fname, 0);
	if (!outctrl->pub.stream)
	{
	log_error(_("can't create '%s': %s\n"), outctrl->pub.newfname,
	strerror(errno) );
	return;
	}
	if (opt.armor)
	{
	outctrl->pub.afx->what = 1;
	push_armor_filter (outctrl->pub.afx, outctrl->pub.stream);
	}
	}
	log_assert( outctrl->pub.stream );
	if (opt.verbose)
	log_info (_("writing public key to '%s'\n"), outctrl->pub.fname );
	}


	/* We create the packets as a tree of kbnodes. Because the
	structure we create is known in advance we simply generate a
	linked list. The first packet is a dummy packet which we flag as
	deleted. The very first packet must always be a KEY packet. */

	start_tree (&pub_root);

	cardkey = get_parameter_bool (para, pCARDKEY);

	/* In the case that the keys are created from the card we need to
	* take the timestamps from the card. Only in this case a
	* pSUBKEYCREATIONDATE or pAUTHKEYCREATIONDATE might be defined and
	* then we need to use that so that the fingerprint of the subkey
	* also matches the pre-computed and stored one on the card. In
	* this case we also use the current time to create the
	* self-signatures. */
	keytimestamp = get_parameter_u32 (para, pKEYCREATIONDATE);
	if (!keytimestamp)
	keytimestamp = make_timestamp ();
	subkeytimestamp = cardkey? get_parameter_u32 (para, pSUBKEYCREATIONDATE) : 0;
	if (!subkeytimestamp)
	subkeytimestamp = keytimestamp;
	authkeytimestamp = cardkey? get_parameter_u32 (para, pAUTHKEYCREATIONDATE): 0;
	if (!authkeytimestamp)
	authkeytimestamp = keytimestamp;

	signtimestamp = cardkey? make_timestamp () : keytimestamp;

	/* log_debug ("XXX: cardkey ..: %d\n", cardkey); */
	/* log_debug ("XXX: keytime ..: %s\n", isotimestamp (keytimestamp)); */
	/* log_debug ("XXX: subkeytime: %s\n", isotimestamp (subkeytimestamp)); */
	/* log_debug ("XXX: authkeytim: %s\n", isotimestamp (authkeytimestamp)); */
	/* log_debug ("XXX: signtime .: %s\n", isotimestamp (signtimestamp)); */

	/* Fixme: Check that this comment is still valid:
	Note that, depending on the backend (i.e. the used scdaemon
	version), the card key generation may update TIMESTAMP for each
	key. Thus we need to pass TIMESTAMP to all signing function to
	make sure that the binding signature is done using the timestamp
	of the corresponding (sub)key and not that of the primary key.
	An alternative implementation could tell the signing function the
	node of the subkey but that is more work than just to pass the
	current timestamp. */

	algo = get_parameter_algo (ctrl, para, pKEYTYPE, NULL );
	expire = get_parameter_u32( para, pKEYEXPIRE );
	key_from_hexgrip = get_parameter_value (para, pKEYGRIP);
	if (cardkey && !key_from_hexgrip)
	BUG ();

	keygen_flags = outctrl->keygen_flags;
	if (get_parameter_uint (para, pVERSION) == 5)
	keygen_flags \|= KEYGEN_FLAG_CREATE_V5_KEY;

	if (key_from_hexgrip)
	err = do_create_from_keygrip (ctrl, algo, key_from_hexgrip, cardkey,
	pub_root,
	keytimestamp,
	expire, 0, &keygen_flags);
	else if (!card)
	err = do_create (algo,
	get_parameter_uint( para, pKEYLENGTH ),
	get_parameter_value (para, pKEYCURVE),
	pub_root,
	keytimestamp,
	expire, 0,
	&keygen_flags,
	get_parameter_passphrase (para),
	&cache_nonce, NULL,
	NULL, NULL);
	else
	err = gen_card_key (1, algo,
	1, pub_root, &keytimestamp,
	expire, &keygen_flags);

	/* Get the pointer to the generated public key packet. */
	if (!err)
	{
	pri_psk = pub_root->next->pkt->pkt.public_key;
	log_assert (pri_psk);

	/* Make sure a few fields are correctly set up before going
	further. */
	pri_psk->flags.primary = 1;
	keyid_from_pk (pri_psk, NULL);
	/* We don't use pk_keyid to get keyid, because it also asserts
	that main_keyid is set! */
	keyid_copy (pri_psk->main_keyid, pri_psk->keyid);
	}

	/* Write all signatures specifying designated revokers. */
	for (idx=0; !err && (revkey = get_parameter_revkey (para, idx)); idx++)
	{
	err = write_direct_sig (ctrl, pub_root, pri_psk,
	revkey, signtimestamp, cache_nonce);
	}

	if (!err && (s = get_parameter_value (para, pUSERID)))
	{
	err = write_uid (pub_root, s );
	if (!err)
	err = write_selfsigs (ctrl, pub_root, pri_psk,
	get_parameter_uint (para, pKEYUSAGE),
	signtimestamp, cache_nonce);
	}

	/* Write the auth key to the card before the encryption key. This
	is a partial workaround for a PGP bug (as of this writing, all
	versions including 8.1), that causes it to try and encrypt to
	the most recent subkey regardless of whether that subkey is
	actually an encryption type. In this case, the auth key is an
	RSA key so it succeeds. */

	if (!err && card && get_parameter (para, pAUTHKEYTYPE))
	{
	err = gen_card_key (3, get_parameter_algo (ctrl, para,
	pAUTHKEYTYPE, NULL ),
	0, pub_root, &authkeytimestamp, expire,
	&keygen_flags);
	if (!err)
	err = write_keybinding (ctrl, pub_root, pri_psk, NULL,
	PUBKEY_USAGE_AUTH, signtimestamp, cache_nonce);
	}

	if (!err && get_parameter (para, pSUBKEYTYPE))
	{
	int subkey_algo = get_parameter_algo (ctrl, para, pSUBKEYTYPE, NULL);

	key_from_hexgrip = get_parameter_value (para, pSUBKEYGRIP);

	keygen_flags = outctrl->keygen_flags;
	if (get_parameter_uint (para, pSUBVERSION) == 5)
	keygen_flags \|= KEYGEN_FLAG_CREATE_V5_KEY;

	if (key_from_hexgrip)
	err = do_create_from_keygrip (ctrl, subkey_algo,
	key_from_hexgrip, cardkey,
	pub_root, subkeytimestamp,
	get_parameter_u32 (para, pSUBKEYEXPIRE),
	1, &keygen_flags);
	else if (get_parameter_value (para, pCARDBACKUPKEY))
	{
	int lastmode;
	unsigned int mykeygenflags = KEYGEN_FLAG_NO_PROTECTION;

	err = agent_set_ephemeral_mode (ctrl, 1, &lastmode);
	if (err)
	log_error ("error switching to ephemeral mode: %s\n",
	gpg_strerror (err));
	else
	{
	err = do_create (subkey_algo,
	get_parameter_uint (para, pSUBKEYLENGTH),
	get_parameter_value (para, pSUBKEYCURVE),
	pub_root,
	subkeytimestamp,
	get_parameter_u32 (para, pSUBKEYEXPIRE), 1,
	&mykeygenflags,
	get_parameter_passphrase (para),
	&cache_nonce, NULL,
	NULL, NULL);
	/* Get the pointer to the generated public subkey packet. */
	if (!err)
	{
	kbnode_t node;

	for (node = pub_root; node; node = node->next)
	if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
	sub_psk = node->pkt->pkt.public_key;
	log_assert (sub_psk);
	err = card_store_key_with_backup (ctrl,
	sub_psk, gnupg_homedir ());
	}

	/* Reset the ephemeral mode as needed. */
	if (!lastmode && agent_set_ephemeral_mode (ctrl, 0, NULL))
	log_error ("error clearing the ephemeral mode\n");
	}
	}
	else if (!card)
	{
	err = do_create (subkey_algo,
	get_parameter_uint (para, pSUBKEYLENGTH),
	get_parameter_value (para, pSUBKEYCURVE),
	pub_root,
	subkeytimestamp,
	get_parameter_u32 (para, pSUBKEYEXPIRE), 1,
	&keygen_flags,
	get_parameter_passphrase (para),
	&cache_nonce, NULL,
	NULL, NULL);
	if (!err)
	{
	kbnode_t node;

	for (node = pub_root; node; node = node->next)
	if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
	sub_psk = node->pkt->pkt.public_key;
	log_assert (sub_psk);
	}
	}
	else
	{
	err = gen_card_key (2, subkey_algo, 0, pub_root,
	&subkeytimestamp, expire, &keygen_flags);
	}

	if (!err)
	err = write_keybinding (ctrl, pub_root, pri_psk, sub_psk,
	get_parameter_uint (para, pSUBKEYUSAGE),
	signtimestamp, cache_nonce);
	did_sub = 1;
	}


	/* Get rid of the first empty packet. */
	if (!err)
	commit_kbnode (&pub_root);

	/* Add ADSKs if any are specified. */
	if (!err)
	{
	PKT_public_key *adsk;

	for (idx=0; (adsk = get_parameter_adsk (para, idx)); idx++)
	{
	err = append_adsk_to_key (ctrl, pub_root, adsk,
	signtimestamp, cache_nonce);
	if (err)
	break;
	any_adsk++;
	}
	}

	if (!err && outctrl->use_files) /* Direct write to specified files. */
	{
	err = write_keyblock (outctrl->pub.stream, pub_root);
	if (err)
	log_error ("can't write public key: %s\n", gpg_strerror (err));
	}
	else if (!err) /* Write to the standard keyrings. */
	{
	KEYDB_HANDLE pub_hd;

	pub_hd = keydb_new (ctrl);
	if (!pub_hd)
	err = gpg_error_from_syserror ();
	else
	{
	err = keydb_locate_writable (pub_hd);
	if (err)
	log_error (_("no writable public keyring found: %s\n"),
	gpg_strerror (err));
	+ else
	+ err = keydb_lock (pub_hd);
	}

	if (!err && opt.verbose)
	{
	log_info (_("writing public key to '%s'\n"),
	keydb_get_resource_name (pub_hd));
	}

	if (!err)
	{
	err = keydb_insert_keyblock (pub_hd, pub_root);
	if (err)
	log_error (_("error writing public keyring '%s': %s\n"),
	keydb_get_resource_name (pub_hd), gpg_strerror (err));
	}

	keydb_release (pub_hd);

	if (!err)
	{
	int no_enc_rsa;
	PKT_public_key *pk;

	no_enc_rsa = ((get_parameter_algo (ctrl, para, pKEYTYPE, NULL)
	== PUBKEY_ALGO_RSA)
	&& get_parameter_uint (para, pKEYUSAGE)
	&& !((get_parameter_uint (para, pKEYUSAGE)
	& PUBKEY_USAGE_ENC)) );

	pk = find_kbnode (pub_root, PKT_PUBLIC_KEY)->pkt->pkt.public_key;

	if (!opt.flags.no_auto_trust_new_key)
	update_ownertrust (ctrl, pk,
	((get_ownertrust (ctrl, pk) & ~TRUST_MASK)
	\| TRUST_ULTIMATE ));

	gen_standard_revoke (ctrl, pk, cache_nonce);

	if (!opt.batch)
	{
	tty_printf (_("public and secret key created and signed.\n") );
	tty_printf ("\n");
	merge_keys_and_selfsig (ctrl, pub_root);

	list_keyblock_direct (ctrl, pub_root, 0, 1,
	opt.fingerprint \|\| opt.with_fingerprint,
	1);
	/* Note that we ignore errors from the list function
	* because that would only be an additional info. It
	* has already been remarked that the key has been
	* created. */
	}

	if (!opt.batch
	&& (get_parameter_algo (ctrl, para,
	pKEYTYPE, NULL) == PUBKEY_ALGO_DSA
	\|\| no_enc_rsa )
	&& !get_parameter (para, pSUBKEYTYPE) )
	{
	tty_printf(_("Note that this key cannot be used for "
	"encryption. You may want to use\n"
	"the command \"--edit-key\" to generate a "
	"subkey for this purpose.\n") );
	}
	}
	}

	if (err)
	{
	if (opt.batch)
	log_error ("key generation failed: %s\n", gpg_strerror (err) );
	else
	tty_printf (_("Key generation failed: %s\n"), gpg_strerror (err) );
	write_status_error (card? "card_key_generate":"key_generate", err);
	print_status_key_not_created ( get_parameter_value (para, pHANDLE) );
	}
	else
	{
	PKT_public_key *pk = find_kbnode (pub_root,
	PKT_PUBLIC_KEY)->pkt->pkt.public_key;
	print_status_key_created (did_sub? 'B':'P', pk,
	get_parameter_value (para, pHANDLE));
	es_fflush (es_stdout);
	if (any_adsk)
	log_info (_("Note: The key has been created with one or more ADSK!\n"));

	if (opt.flags.auto_key_upload)
	{
	unsigned int saved_options = opt.keyserver_options.options;

	opt.keyserver_options.options \|= KEYSERVER_LDAP_ONLY;
	opt.keyserver_options.options \|= KEYSERVER_WARN_ONLY;
	keyserver_export_pubkey (ctrl, pk, 1/Assume new key/);
	opt.keyserver_options.options = saved_options;
	}
	}

	release_kbnode (pub_root);
	xfree (cache_nonce);
	}


	static gpg_error_t
	parse_algo_usage_expire (ctrl_t ctrl, int for_subkey,
	const char algostr, const char usagestr,
	const char *expirestr,
	int r_algo, unsigned int r_usage, u32 *r_expire,
	unsigned int r_nbits, const char *r_curve,
	int r_version, char r_keygrip, u32 r_keytime)
	{
	gpg_error_t err;
	int algo;
	unsigned int use, nbits;
	u32 expire;
	int wantuse;
	int version = 4;
	const char *curve = NULL;

	*r_curve = NULL;
	if (r_keygrip)
	*r_keygrip = NULL;
	if (r_keytime)
	*r_keytime = 0;

	nbits = 0;

	/* Parse the algo string. */
	if (algostr && *algostr == '&' && strlen (algostr) == 41)
	{
	/* Take algo from existing key. */
	algo = check_keygrip (ctrl, algostr+1);
	/* FIXME: We need the curve name as well. */
	return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
	}

	err = parse_key_parameter_string (ctrl, algostr, for_subkey? 1 : 0,
	usagestr? parse_usagestr (usagestr):0,
	&algo, &nbits, &use, &curve, &version,
	r_keygrip, r_keytime,
	NULL, NULL, NULL, NULL, NULL, NULL, NULL);
	if (err)
	{
	if (r_keygrip)
	{
	xfree (*r_keygrip);
	*r_keygrip = NULL;
	}
	return err;
	}

	/* Parse the usage string. */
	if (!usagestr \|\| !*usagestr
	\|\| !ascii_strcasecmp (usagestr, "default") \|\| !strcmp (usagestr, "-"))
	; /* Keep usage from parse_key_parameter_string. */
	else if ((wantuse = parse_usagestr (usagestr)) != -1)
	use = wantuse;
	else
	{
	if (r_keygrip)
	{
	xfree (*r_keygrip);
	*r_keygrip = NULL;
	}
	return gpg_error (GPG_ERR_INV_VALUE);
	}

	/* Now do the tricky ECDSA/ECDH adjustment. */
	algo = adjust_algo_for_ecdh_ecdsa (algo, use, curve);

	/* Make sure a primary key has the CERT usage. */
	if (!for_subkey)
	use \|= PUBKEY_USAGE_CERT;

	/* Check that usage is possible. NB: We have the same check in
	* parse_key_parameter_string but need it here again in case the
	* separate usage value has been given. */
	if (/**/((use & (PUBKEY_USAGE_SIG\|PUBKEY_USAGE_AUTH\|PUBKEY_USAGE_CERT))
	&& !pubkey_get_nsig (algo))
	\|\| ((use & PUBKEY_USAGE_ENC)
	&& !pubkey_get_nenc (algo))
	\|\| (for_subkey && (use & PUBKEY_USAGE_CERT)))
	{
	if (r_keygrip)
	{
	xfree (*r_keygrip);
	*r_keygrip = NULL;
	}
	return gpg_error (GPG_ERR_WRONG_KEY_USAGE);
	}

	/* Parse the expire string. */
	expire = parse_expire_string (expirestr);
	if (expire == (u32)-1 )
	{
	if (r_keygrip)
	{
	xfree (*r_keygrip);
	*r_keygrip = NULL;
	}
	return gpg_error (GPG_ERR_INV_VALUE);
	}

	if (curve)
	*r_curve = curve;
	*r_algo = algo;
	*r_usage = use;
	*r_expire = expire;
	*r_nbits = nbits;
	*r_version = version;
	return 0;
	}


	/* Add a new subkey to an existing key. Returns 0 if a new key has
	been generated and put into the keyblocks. If any of ALGOSTR,
	USAGESTR, or EXPIRESTR is NULL interactive mode is used. */
	gpg_error_t
	generate_subkeypair (ctrl_t ctrl, kbnode_t keyblock, const char *algostr,
	const char usagestr, const char expirestr)
	{
	gpg_error_t err = 0;
	int interactive;
	kbnode_t node;
	PKT_public_key *pri_psk = NULL;
	PKT_public_key *sub_psk = NULL;
	int algo;
	unsigned int use;
	u32 expire;
	unsigned int nbits = 0;
	const char *curve = NULL;
	u32 cur_time;
	char *key_from_hexgrip = NULL;
	u32 keytime = 0;
	int cardkey = 0;
	char *hexgrip = NULL;
	char *serialno = NULL;
	char *cache_nonce = NULL;
	char *passwd_nonce = NULL;
	int keygen_flags = 0;

	interactive = (!algostr \|\| !usagestr \|\| !expirestr);

	/* Break out the primary key. */
	node = find_kbnode (keyblock, PKT_PUBLIC_KEY);
	if (!node)
	{
	log_error ("Oops; primary key missing in keyblock!\n");
	err = gpg_error (GPG_ERR_BUG);
	goto leave;
	}
	pri_psk = node->pkt->pkt.public_key;

	cur_time = make_timestamp ();

	if (pri_psk->timestamp > cur_time)
	{
	ulong d = pri_psk->timestamp - cur_time;
	log_info ( d==1 ? _("key has been created %lu second "
	"in future (time warp or clock problem)\n")
	: _("key has been created %lu seconds "
	"in future (time warp or clock problem)\n"), d );
	if (!opt.ignore_time_conflict)
	{
	err = gpg_error (GPG_ERR_TIME_CONFLICT);
	goto leave;
	}
	}

	if (pri_psk->version < 4)
	{
	log_info (_("Note: creating subkeys for v3 keys "
	"is not OpenPGP compliant\n"));
	err = gpg_error (GPG_ERR_CONFLICT);
	goto leave;
	}

	err = hexkeygrip_from_pk (pri_psk, &hexgrip);
	if (err)
	goto leave;
	/* FIXME: Right now the primary key won't be a dual key. But this
	* will change */
	if (agent_get_keyinfo (NULL, hexgrip, &serialno, NULL))
	{
	if (interactive)
	tty_printf (_("Secret parts of primary key are not available.\n"));
	else
	log_info ( _("Secret parts of primary key are not available.\n"));
	err = gpg_error (GPG_ERR_NO_SECKEY);
	goto leave;
	}
	if (serialno)
	{
	if (interactive)
	tty_printf (_("Secret parts of primary key are stored on-card.\n"));
	else
	log_info ( _("Secret parts of primary key are stored on-card.\n"));
	}

	if (interactive)
	{
	algo = ask_algo (ctrl, 1, NULL, &use, &key_from_hexgrip, &cardkey,
	&keytime);
	log_assert (algo);

	if (key_from_hexgrip)
	nbits = 0;
	else if (algo == PUBKEY_ALGO_ECDSA
	\|\| algo == PUBKEY_ALGO_EDDSA
	\|\| algo == PUBKEY_ALGO_ECDH)
	{
	curve = ask_curve (&algo, NULL, NULL);

	if (curve && (!strcmp (curve, "X448") \|\| !strcmp (curve, "Ed448")))
	keygen_flags \|= KEYGEN_FLAG_CREATE_V5_KEY;
	}
	else if (algo == PUBKEY_ALGO_KYBER)
	{
	const char *kyberalgostr;

	kyberalgostr = ask_kyber_variant ();
	if (!kyberalgostr) /* Should not happen. */
	kyberalgostr = PQC_STD_KEY_PARAM_SUB;

	nbits = strstr (kyberalgostr, "768_")? 768 : 1024;
	curve = strchr (kyberalgostr, '_');
	log_assert (curve && curve[1]);
	curve++;
	}
	else
	nbits = ask_keysize (algo, 0);

	expire = ask_expire_interval (0, NULL);
	if (!cpr_enabled() && !cpr_get_answer_is_yes("keygen.sub.okay",
	_("Really create? (y/N) ")))
	{
	err = gpg_error (GPG_ERR_CANCELED);
	goto leave;
	}
	}
	else /* Unattended mode. */
	{
	int version;

	err = parse_algo_usage_expire (ctrl, 1, algostr, usagestr, expirestr,
	&algo, &use, &expire, &nbits, &curve,
	&version, &key_from_hexgrip, &keytime);
	if (err)
	goto leave;

	if (version == 5)
	keygen_flags \|= KEYGEN_FLAG_CREATE_V5_KEY;
	}

	/* Verify the passphrase now so that we get a cache item for the
	* primary key passphrase. The agent also returns a passphrase
	* nonce, which we can use to set the passphrase for the subkey to
	* that of the primary key. */
	{
	char *desc = gpg_format_keydesc (ctrl, pri_psk, FORMAT_KEYDESC_NORMAL, 1);
	err = agent_passwd (ctrl, hexgrip, desc, 1 /=verify/,
	&cache_nonce, &passwd_nonce);
	xfree (desc);
	if (gpg_err_code (err) == GPG_ERR_NOT_IMPLEMENTED
	&& gpg_err_source (err) == GPG_ERR_SOURCE_GPGAGENT)
	err = 0; /* Very likely that the key is on a card. */
	if (err)
	goto leave;
	}

	/* Start creation. */
	if (key_from_hexgrip)
	{
	err = do_create_from_keygrip (ctrl, algo, key_from_hexgrip, cardkey,
	keyblock,
	keytime? keytime : cur_time,
	expire, 1,
	&keygen_flags);
	}
	else
	{
	const char *passwd;

	/* If the pinentry loopback mode is not and we have a static
	passphrase (i.e. set with --passphrase{,-fd,-file} while in batch
	mode), we use that passphrase for the new subkey. */
	if (opt.pinentry_mode != PINENTRY_MODE_LOOPBACK
	&& have_static_passphrase ())
	passwd = get_static_passphrase ();
	else
	passwd = NULL;

	err = do_create (algo, nbits, curve,
	keyblock, cur_time, expire, 1, &keygen_flags,
	passwd, &cache_nonce, &passwd_nonce, NULL, NULL);
	}
	if (err)
	goto leave;

	/* Get the pointer to the generated public subkey packet. */
	for (node = keyblock; node; node = node->next)
	if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
	sub_psk = node->pkt->pkt.public_key;

	/* Write the binding signature. */
	err = write_keybinding (ctrl, keyblock, pri_psk, sub_psk, use, cur_time,
	cache_nonce);
	if (err)
	goto leave;

	print_status_key_created ('S', sub_psk, NULL);


	leave:
	xfree (key_from_hexgrip);
	xfree (hexgrip);
	xfree (serialno);
	xfree (cache_nonce);
	xfree (passwd_nonce);
	if (err)
	{
	log_error (_("Key generation failed: %s\n"), gpg_strerror (err) );
	write_status_error (cardkey? "card_key_generate":"key_generate", err);
	print_status_key_not_created ( NULL );
	}
	return err;
	}


	#ifdef ENABLE_CARD_SUPPORT
	/* Generate a subkey on a card. */
	gpg_error_t
	generate_card_subkeypair (ctrl_t ctrl, kbnode_t pub_keyblock,
	int keyno, const char *serialno)
	{
	gpg_error_t err = 0;
	kbnode_t node;
	PKT_public_key *pri_pk = NULL;
	unsigned int use;
	u32 expire;
	u32 cur_time;
	struct para_data_s *para = NULL;
	PKT_public_key *sub_pk = NULL;
	int algo;
	struct agent_card_info_s info;
	int keygen_flags = 0; /* FIXME!!! */

	log_assert (keyno >= 1 && keyno <= 3);

	memset (&info, 0, sizeof (info));
	err = agent_scd_getattr ("KEY-ATTR", &info);
	if (err)
	{
	log_error (_("error getting current key info: %s\n"), gpg_strerror (err));
	return err;
	}
	algo = info.key_attr[keyno-1].algo;

	para = xtrycalloc (1, sizeof *para + strlen (serialno) );
	if (!para)
	{
	err = gpg_error_from_syserror ();
	goto leave;
	}
	para->key = pSERIALNO;
	strcpy (para->u.value, serialno);

	/* Break out the primary secret key */
	node = find_kbnode (pub_keyblock, PKT_PUBLIC_KEY);
	if (!node)
	{
	log_error ("Oops; public key lost!\n");
	err = gpg_error (GPG_ERR_INTERNAL);
	goto leave;
	}
	pri_pk = node->pkt->pkt.public_key;

	cur_time = make_timestamp();
	if (pri_pk->timestamp > cur_time)
	{
	ulong d = pri_pk->timestamp - cur_time;
	log_info (d==1 ? _("key has been created %lu second "
	"in future (time warp or clock problem)\n")
	: _("key has been created %lu seconds "
	"in future (time warp or clock problem)\n"), d );
	if (!opt.ignore_time_conflict)
	{
	err = gpg_error (GPG_ERR_TIME_CONFLICT);
	goto leave;
	}
	}

	if (pri_pk->version < 4)
	{
	log_info (_("Note: creating subkeys for v3 keys "
	"is not OpenPGP compliant\n"));
	err = gpg_error (GPG_ERR_NOT_SUPPORTED);
	goto leave;
	}

	expire = ask_expire_interval (0, NULL);
	if (keyno == 1)
	use = PUBKEY_USAGE_SIG;
	else if (keyno == 2)
	use = PUBKEY_USAGE_ENC;
	else
	use = PUBKEY_USAGE_AUTH;
	if (!cpr_enabled() && !cpr_get_answer_is_yes("keygen.cardsub.okay",
	_("Really create? (y/N) ")))
	{
	err = gpg_error (GPG_ERR_CANCELED);
	goto leave;
	}

	/* Note, that depending on the backend, the card key generation may
	update CUR_TIME. */
	err = gen_card_key (keyno, algo, 0, pub_keyblock, &cur_time, expire,
	&keygen_flags);
	/* Get the pointer to the generated public subkey packet. */
	if (!err)
	{
	for (node = pub_keyblock; node; node = node->next)
	if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
	sub_pk = node->pkt->pkt.public_key;
	log_assert (sub_pk);
	err = write_keybinding (ctrl, pub_keyblock, pri_pk, sub_pk,
	use, cur_time, NULL);
	}

	leave:
	if (err)
	log_error (_("Key generation failed: %s\n"), gpg_strerror (err) );
	else
	print_status_key_created ('S', sub_pk, NULL);
	release_parameter_list (para);
	return err;
	}
	#endif /* !ENABLE_CARD_SUPPORT */

	/*
	* Write a keyblock to an output stream
	*/
	static int
	write_keyblock( IOBUF out, KBNODE node )
	{
	for( ; node ; node = node->next )
	{
	if(!is_deleted_kbnode(node))
	{
	int rc = build_packet( out, node->pkt );
	if( rc )
	{
	log_error("build_packet(%d) failed: %s\n",
	node->pkt->pkttype, gpg_strerror (rc) );
	return rc;
	}
	}
	}

	return 0;
	}


	/* Note that timestamp is an in/out arg. */
	static gpg_error_t
	gen_card_key (int keyno, int algo, int is_primary, kbnode_t pub_root,
	u32 timestamp, u32 expireval, int keygen_flags)
	{
	#ifdef ENABLE_CARD_SUPPORT
	gpg_error_t err;
	PACKET *pkt;
	PKT_public_key *pk;
	char keyid[10];
	unsigned char *public;
	gcry_sexp_t s_key;

	snprintf (keyid, DIM(keyid), "OPENPGP.%d", keyno);

	pk = xtrycalloc (1, sizeof *pk );
	if (!pk)
	return gpg_error_from_syserror ();
	pkt = xtrycalloc (1, sizeof *pkt);
	if (!pkt)
	{
	xfree (pk);
	return gpg_error_from_syserror ();
	}

	/* Note: SCD knows the serialnumber, thus there is no point in passing it. */
	err = agent_scd_genkey (keyno, 1, timestamp);
	/* The code below is not used because we force creation of
	* the a card key (3rd arg).
	* if (gpg_err_code (rc) == GPG_ERR_EEXIST)
	* {
	* tty_printf ("\n");
	* log_error ("WARNING: key does already exists!\n");
	* tty_printf ("\n");
	* if ( cpr_get_answer_is_yes( "keygen.card.replace_key",
	* _("Replace existing key? ")))
	* rc = agent_scd_genkey (keyno, 1, timestamp);
	* }
	*/
	if (err)
	{
	log_error ("key generation failed: %s\n", gpg_strerror (err));
	xfree (pkt);
	xfree (pk);
	return err;
	}

	/* Send the READKEY command so that the agent creates a shadow key for
	card key. We need to do that now so that we are able to create
	the self-signatures. */
	err = agent_readkey (NULL, 1, keyid, &public);
	if (err)
	{
	xfree (pkt);
	xfree (pk);
	return err;
	}
	err = gcry_sexp_sscan (&s_key, NULL, public,
	gcry_sexp_canon_len (public, 0, NULL, NULL));
	xfree (public);
	if (err)
	{
	xfree (pkt);
	xfree (pk);
	return err;
	}

	/* Force creation of v5 keys for X448. */
	if (curve_is_448 (s_key))
	*keygen_flags \|= KEYGEN_FLAG_CREATE_V5_KEY;

	pk->version = (*keygen_flags & KEYGEN_FLAG_CREATE_V5_KEY)? 5 : 4;

	if (algo == PUBKEY_ALGO_RSA)
	err = key_from_sexp (pk->pkey, s_key, "public-key", "ne");
	else if (algo == PUBKEY_ALGO_ECDSA
	\|\| algo == PUBKEY_ALGO_EDDSA
	\|\| algo == PUBKEY_ALGO_ECDH )
	err = ecckey_from_sexp (pk->pkey, s_key, NULL, algo, pk->version);
	else
	err = gpg_error (GPG_ERR_PUBKEY_ALGO);
	gcry_sexp_release (s_key);

	if (err)
	{
	log_error ("key_from_sexp failed: %s\n", gpg_strerror (err) );
	free_public_key (pk);
	return err;
	}

	pk->timestamp = *timestamp;
	if (expireval)
	pk->expiredate = pk->timestamp + expireval;
	pk->pubkey_algo = algo;

	pkt->pkttype = is_primary ? PKT_PUBLIC_KEY : PKT_PUBLIC_SUBKEY;
	pkt->pkt.public_key = pk;
	add_kbnode (pub_root, new_kbnode (pkt));

	return 0;
	#else
	(void)keyno;
	(void)is_primary;
	(void)pub_root;
	(void)timestamp;
	(void)expireval;
	return gpg_error (GPG_ERR_NOT_SUPPORTED);
	#endif /!ENABLE_CARD_SUPPORT/
	}
	diff --git a/sm/delete.c b/sm/delete.c
	index ccd389313..46d3a6f2a 100644
	--- a/sm/delete.c
	+++ b/sm/delete.c
	@@ -1,180 +1,180 @@
	/* delete.c - Delete certificates from the keybox.
	* Copyright (C) 2002, 2009 Free Software Foundation, Inc.
	*
	* This file is part of GnuPG.
	*
	* GnuPG is free software; you can redistribute it and/or modify
	* it under the terms of the GNU General Public License as published by
	* the Free Software Foundation; either version 3 of the License, or
	* (at your option) any later version.
	*
	* GnuPG is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with this program; if not, see <https://www.gnu.org/licenses/>.
	*/

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

	#include "gpgsm.h"
	#include <gcrypt.h>
	#include <ksba.h>

	#include "keydb.h"
	#include "../common/i18n.h"


	/* Delete a certificate or an secret key from a key database. */
	static int
	delete_one (ctrl_t ctrl, const char *username)
	{
	int rc = 0;
	KEYDB_SEARCH_DESC desc;
	KEYDB_HANDLE kh = NULL;
	ksba_cert_t cert = NULL;
	int duplicates = 0;
	int is_ephem = 0;

	rc = classify_user_id (username, &desc, 0);
	if (rc)
	{
	log_error (_("certificate '%s' not found: %s\n"),
	username, gpg_strerror (rc));
	gpgsm_status2 (ctrl, STATUS_DELETE_PROBLEM, "1", NULL);
	goto leave;
	}

	kh = keydb_new (ctrl);
	if (!kh)
	{
	log_error ("keydb_new failed\n");
	goto leave;
	}

	+ /* Note that the lock is kept until the KH is released. */
	+ rc = keydb_lock (kh);
	+ if (rc)
	+ {
	+ log_error (_("error locking keybox: %s\n"), gpg_strerror (rc));
	+ goto leave;
	+ }
	+
	/* If the key is specified in a unique way, include ephemeral keys
	in the search. */
	if ( desc.mode == KEYDB_SEARCH_MODE_FPR
	\|\| desc.mode == KEYDB_SEARCH_MODE_KEYGRIP )
	{
	is_ephem = 1;
	keydb_set_ephemeral (kh, 1);
	}

	rc = keydb_search (ctrl, kh, &desc, 1);
	if (!rc)
	rc = keydb_get_cert (kh, &cert);
	if (!rc && !is_ephem)
	{
	unsigned char fpr[20];

	gpgsm_get_fingerprint (cert, 0, fpr, NULL);

	next_ambigious:
	rc = keydb_search (ctrl, kh, &desc, 1);
	if (gpg_err_code (rc) == GPG_ERR_NOT_FOUND)
	rc = 0;
	else if (!rc)
	{
	ksba_cert_t cert2 = NULL;
	unsigned char fpr2[20];

	/* We ignore all duplicated certificates which might have
	been inserted due to program bugs. */
	if (!keydb_get_cert (kh, &cert2))
	{
	gpgsm_get_fingerprint (cert2, 0, fpr2, NULL);
	ksba_cert_release (cert2);
	if (!memcmp (fpr, fpr2, 20))
	{
	duplicates++;
	goto next_ambigious;
	}
	}
	rc = gpg_error (GPG_ERR_AMBIGUOUS_NAME);
	}
	}
	if (rc)
	{
	if (gpg_err_code (rc) == GPG_ERR_NOT_FOUND)
	rc = gpg_error (GPG_ERR_NO_PUBKEY);
	log_error (_("certificate '%s' not found: %s\n"),
	username, gpg_strerror (rc));
	gpgsm_status2 (ctrl, STATUS_DELETE_PROBLEM, "3", NULL);
	goto leave;
	}

	- /* We need to search again to get back to the right position. Note
	- * that the lock is kept until the KH is released. */
	- rc = keydb_lock (kh);
	- if (rc)
	- {
	- log_error (_("error locking keybox: %s\n"), gpg_strerror (rc));
	- goto leave;
	- }
	-
	+ /* We need to search again to get back to the right position. */
	do
	{
	keydb_search_reset (kh);
	rc = keydb_search (ctrl, kh, &desc, 1);
	if (rc)
	{
	log_error ("problem re-searching certificate: %s\n",
	gpg_strerror (rc));
	goto leave;
	}

	rc = keydb_delete (kh);
	if (rc)
	goto leave;
	if (opt.verbose)
	{
	if (duplicates)
	log_info (_("duplicated certificate '%s' deleted\n"), username);
	else
	log_info (_("certificate '%s' deleted\n"), username);
	}
	}
	while (duplicates--);

	leave:
	keydb_release (kh);
	ksba_cert_release (cert);
	return rc;
	}



	/* Delete the certificates specified by NAMES. */
	int
	gpgsm_delete (ctrl_t ctrl, strlist_t names)
	{
	int rc;

	if (!names)
	{
	log_error ("nothing to delete\n");
	return gpg_error (GPG_ERR_NO_DATA);
	}

	for (; names; names=names->next )
	{
	rc = delete_one (ctrl, names->d);
	if (rc)
	{
	log_error (_("deleting certificate \"%s\" failed: %s\n"),
	names->d, gpg_strerror (rc) );
	return rc;
	}
	}

	return 0;
	}
	diff --git a/sm/keydb.c b/sm/keydb.c
	index 72bad2d60..878781cd4 100644
	--- a/sm/keydb.c
	+++ b/sm/keydb.c
	@@ -1,2203 +1,2204 @@
	/* keydb.c - key database dispatcher
	* Copyright (C) 2001, 2003, 2004 Free Software Foundation, Inc.
	* Copyright (C) 2014, 2020 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 <sys/types.h>
	#include <sys/stat.h>
	#include <unistd.h>

	#include "gpgsm.h"
	#include <assuan.h>
	#include "../kbx/keybox.h"
	#include "keydb.h"
	#include "../common/i18n.h"
	#include "../common/asshelp.h"
	#include "../common/comopt.h"
	#include "../kbx/kbx-client-util.h"


	typedef enum {
	KEYDB_RESOURCE_TYPE_NONE = 0,
	KEYDB_RESOURCE_TYPE_KEYBOX
	} KeydbResourceType;
	#define MAX_KEYDB_RESOURCES 20

	struct resource_item {
	KeydbResourceType type;
	union {
	KEYBOX_HANDLE kr;
	} u;
	void *token;
	};


	/* Data used to keep track of keybox daemon sessions. This allows us
	* to use several sessions with the keyboxd and also to reuse already
	* established sessions. Note that gpgdm.h defines the type
	* keydb_local_t for this structure. */
	struct keydb_local_s
	{
	/* Link to other keyboxd contexts which are used simultaneously. */
	struct keydb_local_s *next;

	/* The active Assuan context. */
	assuan_context_t ctx;

	/* The client data helper context. */
	kbx_client_data_t kcd;

	/* I/O buffer with the last search result or NULL. Used if
	* D-lines are used to convey the keyblocks. */
	struct {
	char *buf;
	size_t len;
	} search_result;
	/* The "stack" used by keydb_push_found_state. */
	struct {
	char *buf;
	size_t len;
	} saved_search_result;

	/* This flag set while an operation is running on this context. */
	unsigned int is_active : 1;

	/* Flag indicating that a search reset is required. */
	unsigned int need_search_reset : 1;
	};


	static struct resource_item all_resources[MAX_KEYDB_RESOURCES];
	static int used_resources;

	/* Whether we have successfully registered any resource. */
	static int any_registered;

	/* Number of active handles. */
	static int active_handles;



	struct keydb_handle {

	/* CTRL object passed to keydb_new. */
	ctrl_t ctrl;

	/* If set the keyboxdd is used instead of the local files. */
	int use_keyboxd;

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

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

	/* Various flags. */
	unsigned int last_ubid_valid:1;
	unsigned int last_is_ephemeral; /* Last found key is ephemeral. */

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

	/* END USE_KEYBOXD */

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

	/* If this flag is set the resources is locked. */
	int locked;

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

	int found;
	int saved_found;
	int current;
	int is_ephemeral;
	int used; /* items in active */
	struct resource_item active[MAX_KEYDB_RESOURCES];

	/* END !USE_KEYBOXD */
	};


	static int lock_all (KEYDB_HANDLE hd);
	static void unlock_all (KEYDB_HANDLE hd);



	/* Deinitialize all session resources pertaining to the keyboxd. */
	void
	gpgsm_keydb_deinit_session_data (ctrl_t ctrl)
	{
	keydb_local_t kbl;

	while ((kbl = ctrl->keydb_local))
	{
	ctrl->keydb_local = kbl->next;
	if (kbl->is_active)
	log_error ("oops: trying to cleanup an active keydb context\n");
	else
	{
	assuan_release (kbl->ctx);
	kbl->ctx = NULL;
	/*
	* Since there may be pipe output FD sent to the server (so
	* that it can receive data through the pipe), we should
	* release the assuan connection before releasing KBL->KCD.
	* This way, the data receiving thread can finish cleanly,
	* and we can join the thread.
	*/
	kbx_client_data_release (kbl->kcd);
	kbl->kcd = NULL;
	}
	xfree (kbl);
	}
	}


	static void
	try_make_homedir (const char *fname)
	{
	if ( opt.dry_run \|\| opt.no_homedir_creation )
	return;

	gnupg_maybe_make_homedir (fname, opt.quiet);
	}


	/* Handle the creation of a keybox if it does not yet exist. Take
	into account that other processes might have the keybox already
	locked. This lock check does not work if the directory itself is
	not yet available. If R_CREATED is not NULL it will be set to true
	if the function created a new keybox. */
	static gpg_error_t
	maybe_create_keybox (char filename, int force, int r_created)
	{
	gpg_err_code_t ec;
	dotlock_t lockhd = NULL;
	estream_t fp;
	int rc;
	mode_t oldmask;
	char *last_slash_in_filename;
	int save_slash;

	if (r_created)
	*r_created = 0;

	/* A quick test whether the filename already exists. */
	if (!gnupg_access (filename, F_OK))
	return !gnupg_access (filename, R_OK)? 0 : gpg_error (GPG_ERR_EACCES);

	/* If we don't want to create a new file at all, there is no need to
	go any further - bail out right here. */
	if (!force)
	return gpg_error (GPG_ERR_ENOENT);

	/* First of all we try to create the home directory. Note, that we
	don't do any locking here because any sane application of gpg
	would create the home directory by itself and not rely on gpg's
	tricky auto-creation which is anyway only done for some home
	directory name patterns. */
	last_slash_in_filename = strrchr (filename, DIRSEP_C);
	#if HAVE_W32_SYSTEM
	{
	/* Windows may either have a slash or a backslash. Take care of it. */
	char *p = strrchr (filename, '/');
	if (!last_slash_in_filename \|\| p > last_slash_in_filename)
	last_slash_in_filename = p;
	}
	#endif /HAVE_W32_SYSTEM/
	if (!last_slash_in_filename)
	return gpg_error (GPG_ERR_ENOENT); /* No slash at all - should
	not happen though. */
	save_slash = *last_slash_in_filename;
	*last_slash_in_filename = 0;
	if (gnupg_access(filename, F_OK))
	{
	static int tried;

	if (!tried)
	{
	tried = 1;
	try_make_homedir (filename);
	}
	if ((ec = gnupg_access (filename, F_OK)))
	{
	rc = gpg_error (ec);
	*last_slash_in_filename = save_slash;
	goto leave;
	}
	*last_slash_in_filename = save_slash;

	if (!opt.use_keyboxd
	&& !parse_comopt (GNUPG_MODULE_NAME_GPG, 0)
	&& comopt.use_keyboxd)
	{
	/* The above try_make_homedir created a new default hoemdir
	* and also wrote a new common.conf. Thus we now see that
	* use-keyboxd has been set. Let's set this option and
	* return a dedicated error code. */
	opt.use_keyboxd = comopt.use_keyboxd;
	rc = gpg_error (GPG_ERR_TRUE);
	goto leave;
	}
	}
	else
	*last_slash_in_filename = save_slash;

	/* To avoid races with other instances of gpg trying to create or
	update the keybox (it is removed during an update for a short
	time), we do the next stuff in a locked state. */
	lockhd = dotlock_create (filename, 0);
	if (!lockhd)
	{
	/* A reason for this to fail is that the directory is not
	writable. However, this whole locking stuff does not make
	sense if this is the case. An empty non-writable directory
	with no keyring is not really useful at all. */
	if (opt.verbose)
	log_info ("can't allocate lock for '%s'\n", filename );

	if (!force)
	return gpg_error (GPG_ERR_ENOENT);
	else
	return gpg_error (GPG_ERR_GENERAL);
	}

	if ( dotlock_take (lockhd, -1) )
	{
	/* This is something bad. Probably a stale lockfile. */
	log_info ("can't lock '%s'\n", filename);
	rc = gpg_error (GPG_ERR_GENERAL);
	goto leave;
	}

	/* Now the real test while we are locked. */
	if (!gnupg_access(filename, F_OK))
	{
	rc = 0; /* Okay, we may access the file now. */
	goto leave;
	}

	/* The file does not yet exist, create it now. */
	oldmask = umask (077);
	fp = es_fopen (filename, "wb");
	if (!fp)
	{
	rc = gpg_error_from_syserror ();
	umask (oldmask);
	log_error (_("error creating keybox '%s': %s\n"),
	filename, gpg_strerror (rc));
	goto leave;
	}
	umask (oldmask);

	/* Make sure that at least one record is in a new keybox file, so
	that the detection magic for OpenPGP keyboxes works the next time
	it is used. */
	rc = _keybox_write_header_blob (fp, 0);
	if (rc)
	{
	es_fclose (fp);
	log_error (_("error creating keybox '%s': %s\n"),
	filename, gpg_strerror (rc));
	goto leave;
	}

	if (!opt.quiet)
	log_info (_("keybox '%s' created\n"), filename);
	if (r_created)
	*r_created = 1;

	es_fclose (fp);
	rc = 0;

	leave:
	if (lockhd)
	{
	dotlock_release (lockhd);
	dotlock_destroy (lockhd);
	}
	return rc;
	}


	/*
	* Register a resource (which currently may only be a keybox file).
	* The first keybox which is added by this function is created if it
	* does not exist. If AUTO_CREATED is not NULL it will be set to true
	* if the function has created a new keybox.
	*/
	gpg_error_t
	keydb_add_resource (ctrl_t ctrl, const char url, int force, int auto_created)
	{
	const char *resname = url;
	char *filename = NULL;
	gpg_error_t err = 0;
	KeydbResourceType rt = KEYDB_RESOURCE_TYPE_NONE;

	if (auto_created)
	*auto_created = 0;

	/* Do we have an URL?
	gnupg-kbx:filename := this is a plain keybox
	filename := See what it is, but create as plain keybox.
	*/
	if (strlen (resname) > 10)
	{
	if (!strncmp (resname, "gnupg-kbx:", 10) )
	{
	rt = KEYDB_RESOURCE_TYPE_KEYBOX;
	resname += 10;
	}
	#if !defined(HAVE_DRIVE_LETTERS) && !defined(__riscos__)
	else if (strchr (resname, ':'))
	{
	log_error ("invalid key resource URL '%s'\n", url );
	err = gpg_error (GPG_ERR_GENERAL);
	goto leave;
	}
	#endif /* !HAVE_DRIVE_LETTERS && !__riscos__ */
	}

	if (*resname != DIRSEP_C )
	{ /* do tilde expansion etc */
	if (strchr(resname, DIRSEP_C) )
	filename = make_filename (resname, NULL);
	else
	filename = make_filename (gnupg_homedir (), resname, NULL);
	}
	else
	filename = xstrdup (resname);

	if (!force)
	force = !any_registered;

	/* see whether we can determine the filetype */
	if (rt == KEYDB_RESOURCE_TYPE_NONE)
	{
	estream_t fp;

	fp = es_fopen( filename, "rb" );
	if (fp)
	{
	u32 magic;

	/* FIXME: check for the keybox magic */
	if (es_fread (&magic, 4, 1, fp) == 1 )
	{
	if (magic == 0x13579ace \|\| magic == 0xce9a5713)
	; /* GDBM magic - no more support */
	else
	rt = KEYDB_RESOURCE_TYPE_KEYBOX;
	}
	else /* maybe empty: assume keybox */
	rt = KEYDB_RESOURCE_TYPE_KEYBOX;

	es_fclose (fp);
	}
	else /* no file yet: create keybox */
	rt = KEYDB_RESOURCE_TYPE_KEYBOX;
	}

	switch (rt)
	{
	case KEYDB_RESOURCE_TYPE_NONE:
	log_error ("unknown type of key resource '%s'\n", url );
	err = gpg_error (GPG_ERR_GENERAL);
	goto leave;

	case KEYDB_RESOURCE_TYPE_KEYBOX:
	err = maybe_create_keybox (filename, force, auto_created);
	if (err)
	goto leave;
	/* Now register the file */
	{
	void *token;

	err = keybox_register_file (filename, 0, &token);
	if (gpg_err_code (err) == GPG_ERR_EEXIST)
	; /* Already registered - ignore. */
	else if (err)
	; /* Other error. */
	else if (used_resources >= MAX_KEYDB_RESOURCES)
	err = gpg_error (GPG_ERR_RESOURCE_LIMIT);
	else
	{
	all_resources[used_resources].type = rt;
	all_resources[used_resources].u.kr = NULL; /* Not used here */
	all_resources[used_resources].token = token;

	/* Do a compress run if needed and no other user is
	* currently using the keybox. */
	keybox_compress_when_no_other_users (token, 0);
	used_resources++;
	}
	}
	break;

	default:
	log_error ("resource type of '%s' not supported\n", url);
	err = gpg_error (GPG_ERR_NOT_SUPPORTED);
	goto leave;
	}

	/* fixme: check directory permissions and print a warning */

	leave:
	if (err)
	{
	if (gpg_err_code (err) != GPG_ERR_TRUE)
	{
	log_error ("keyblock resource '%s': %s\n",
	filename, gpg_strerror (err));
	gpgsm_status_with_error (ctrl, STATUS_ERROR,
	"add_keyblock_resource", err);
	}
	}
	else
	any_registered = 1;
	xfree (filename);
	return err;
	}


	/* Print a warning if the server's version number is less than our
	version number. Returns an error code on a connection problem. */
	static gpg_error_t
	warn_version_mismatch (ctrl_t ctrl, assuan_context_t ctx,
	const char *servername)
	{
	return warn_server_version_mismatch (ctx, servername, 0,
	gpgsm_status2, ctrl,
	!opt.quiet);
	}


	/* Connect to the keybox daemon and launch it if necessary. Handle
	* the server's initial greeting and set global options. Returns a
	* new assuan context or an error. */
	static gpg_error_t
	create_new_context (ctrl_t ctrl, assuan_context_t *r_ctx)
	{
	gpg_error_t err;
	assuan_context_t ctx;

	*r_ctx = NULL;

	err = start_new_keyboxd (&ctx,
	GPG_ERR_SOURCE_DEFAULT,
	opt.keyboxd_program,
	opt.autostart?ASSHELP_FLAG_AUTOSTART:0,
	opt.verbose, DBG_IPC,
	NULL, ctrl);
	if (!opt.autostart && gpg_err_code (err) == GPG_ERR_NO_KEYBOXD)
	{
	static int shown;

	if (!shown)
	{
	shown = 1;
	log_info (_("no keyboxd running in this session\n"));
	}
	}
	else if (!err && !(err = warn_version_mismatch (ctrl, ctx, KEYBOXD_NAME)))
	{
	/* Place to emit global options. */
	}

	if (err)
	assuan_release (ctx);
	else
	*r_ctx = ctx;

	return err;
	}


	/* Get a context for accessing keyboxd. If no context is available a
	* new one is created and if necessary keyboxd is started. R_KBL
	* receives a pointer to the local context object. */
	static gpg_error_t
	open_context (ctrl_t ctrl, keydb_local_t *r_kbl)
	{
	gpg_error_t err;
	keydb_local_t kbl;

	*r_kbl = NULL;
	for (;;)
	{
	for (kbl = ctrl->keydb_local; kbl && kbl->is_active; kbl = kbl->next)
	;
	if (kbl)
	{
	/* Found an inactive keyboxd session - return that. */
	log_assert (!kbl->is_active);

	kbl->is_active = 1;
	kbl->need_search_reset = 1;

	*r_kbl = kbl;
	return 0;
	}

	/* None found. Create a new session and retry. */
	kbl = xtrycalloc (1, sizeof *kbl);
	if (!kbl)
	return gpg_error_from_syserror ();

	err = create_new_context (ctrl, &kbl->ctx);
	if (err)
	{
	xfree (kbl);
	return err;
	}

	err = kbx_client_data_new (&kbl->kcd, kbl->ctx, 0);
	if (err)
	{
	assuan_release (kbl->ctx);
	xfree (kbl);
	return err;
	}

	/* For thread-saftey we add it to the list and retry; this is
	* easier than to employ a lock. */
	kbl->next = ctrl->keydb_local;
	ctrl->keydb_local = kbl;
	}
	/NOTREACHED/
	}


	KEYDB_HANDLE
	keydb_new (ctrl_t ctrl)
	{
	gpg_error_t err;
	KEYDB_HANDLE hd;
	int rc, i, j;

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

	hd = xcalloc (1, sizeof *hd);
	hd->found = -1;
	hd->saved_found = -1;
	hd->use_keyboxd = opt.use_keyboxd;
	hd->ctrl = ctrl;
	if (hd->use_keyboxd)
	{
	err = open_context (ctrl, &hd->kbl);
	if (err)
	{
	log_error (_("error opening key DB: %s\n"), gpg_strerror (err));
	xfree (hd);
	hd = NULL;
	if (!(rc = gpg_err_code_to_errno (err)))
	rc = gpg_err_code_to_errno (GPG_ERR_EIO);
	gpg_err_set_errno (rc);
	goto leave;
	}
	}
	else /* Use the local keybox. */
	{
	log_assert (used_resources <= MAX_KEYDB_RESOURCES);
	for (i=j=0; i < used_resources; i++)
	{
	switch (all_resources[i].type)
	{
	case KEYDB_RESOURCE_TYPE_NONE: /* ignore */
	break;
	case KEYDB_RESOURCE_TYPE_KEYBOX:
	hd->active[j].type = all_resources[i].type;
	hd->active[j].token = all_resources[i].token;
	hd->active[j].u.kr = keybox_new_x509 (all_resources[i].token, 0);
	if (!hd->active[j].u.kr)
	{
	xfree (hd);
	return NULL; /* fixme: free all previously allocated handles*/
	}
	j++;
	break;
	}
	}
	hd->used = j;
	}

	active_handles++;

	leave:
	if (DBG_CLOCK)
	log_clock ("%s: leave (hd=%p)\n", __func__, hd);
	return hd;
	}

	void
	keydb_release (KEYDB_HANDLE hd)
	{
	keydb_local_t kbl;
	int i;

	if (!hd)
	return;

	if (DBG_CLOCK)
	log_clock ("%s: enter (hd=%p)\n", __func__, hd);

	log_assert (active_handles > 0);
	active_handles--;

	if (hd->use_keyboxd)
	{
	kbl = hd->kbl;
	if (DBG_CLOCK)
	log_clock ("close_context (found)");
	if (!kbl->is_active)
	log_fatal ("closing inactive keyboxd context %p\n", kbl);
	kbl->is_active = 0;
	hd->kbl = NULL;
	}
	else
	{
	hd->keep_lock = 0;
	unlock_all (hd);
	for (i=0; i < hd->used; i++)
	{
	switch (hd->active[i].type)
	{
	case KEYDB_RESOURCE_TYPE_NONE:
	break;
	case KEYDB_RESOURCE_TYPE_KEYBOX:
	keybox_release (hd->active[i].u.kr);
	break;
	}
	}
	}

	xfree (hd);
	if (DBG_CLOCK)
	log_clock ("%s: leave\n", __func__);
	}


	/* Return the name of the current resource. This is function first
	looks for the last found found, then for the current search
	position, and last returns the first available resource. The
	returned string is only valid as long as the handle exists. This
	function does only return NULL if no handle is specified, in all
	other error cases an empty string is returned. */
	const char *
	keydb_get_resource_name (KEYDB_HANDLE hd)
	{
	int idx;
	const char *s = NULL;

	if (!hd)
	return NULL;

	if (hd->use_keyboxd)
	return "[keyboxd]";

	if ( hd->found >= 0 && hd->found < hd->used)
	idx = hd->found;
	else if ( hd->current >= 0 && hd->current < hd->used)
	idx = hd->current;
	else
	idx = 0;

	switch (hd->active[idx].type)
	{
	case KEYDB_RESOURCE_TYPE_NONE:
	s = NULL;
	break;
	case KEYDB_RESOURCE_TYPE_KEYBOX:
	s = keybox_get_resource_name (hd->active[idx].u.kr);
	break;
	}

	return s? s: "";
	}

	/* Switch the handle into ephemeral mode and return the original value. */
	int
	keydb_set_ephemeral (KEYDB_HANDLE hd, int yes)
	{
	int i;

	if (!hd)
	return 0;

	if (hd->use_keyboxd)
	return 0; /* FIXME: No support yet. */


	yes = !!yes;
	if (hd->is_ephemeral != yes)
	{
	for (i=0; i < hd->used; i++)
	{
	switch (hd->active[i].type)
	{
	case KEYDB_RESOURCE_TYPE_NONE:
	break;
	case KEYDB_RESOURCE_TYPE_KEYBOX:
	keybox_set_ephemeral (hd->active[i].u.kr, yes);
	break;
	}
	}
	}

	i = hd->is_ephemeral;
	hd->is_ephemeral = yes;
	return i;
	}


	/* If the keyring has not yet been locked, lock it now. This
	* operation is required before any update operation; it is optional
	* for an insert operation. The lock is kept until a keydb_release so
	* that internal unlock_all calls have no effect. */
	gpg_error_t
	keydb_lock (KEYDB_HANDLE hd)
	{
	gpg_error_t err;

	if (!hd)
	return gpg_error (GPG_ERR_INV_HANDLE);
	if (hd->use_keyboxd)
	return 0;

	if (DBG_CLOCK)
	log_clock ("%s: enter (hd=%p)\n", __func__, hd);
	err = lock_all (hd);
	if (!err)
	hd->keep_lock = 1;

	if (DBG_CLOCK)
	log_clock ("%s: leave (err=%s)\n", __func__, gpg_strerror (err));
	return err;
	}



	static int
	lock_all (KEYDB_HANDLE hd)
	{
	int i, rc = 0;

	if (hd->keep_lock)
	return 0;

	/* Fixme: This locking scheme may lead to deadlock if the resources
	are not added in the same order by all processes. We are
	currently only allowing one resource so it is not a problem. */
	for (i=0; i < hd->used; i++)
	{
	switch (hd->active[i].type)
	{
	case KEYDB_RESOURCE_TYPE_NONE:
	break;
	case KEYDB_RESOURCE_TYPE_KEYBOX:
	rc = keybox_lock (hd->active[i].u.kr, 1, -1);
	break;
	}
	if (rc)
	break;
	}

	if (rc)
	{
	/* Revert the already set locks. */
	for (i--; i >= 0; i--)
	{
	switch (hd->active[i].type)
	{
	case KEYDB_RESOURCE_TYPE_NONE:
	break;
	case KEYDB_RESOURCE_TYPE_KEYBOX:
	keybox_lock (hd->active[i].u.kr, 0, 0);
	break;
	}
	}
	}
	else
	hd->locked = 1;

	return rc;
	}

	static void
	do_fp_close (KEYDB_HANDLE hd)
	{
	int i;

	for (i=0; i < hd->used; i++)
	{
	switch (hd->active[i].type)
	{
	case KEYDB_RESOURCE_TYPE_NONE:
	break;
	case KEYDB_RESOURCE_TYPE_KEYBOX:
	keybox_fp_close (hd->active[i].u.kr);
	break;
	}
	}
	}

	static void
	unlock_all (KEYDB_HANDLE hd)
	{
	int i;

	do_fp_close (hd);

	if (!hd->locked)
	return;

	for (i=hd->used-1; i >= 0; i--)
	{
	switch (hd->active[i].type)
	{
	case KEYDB_RESOURCE_TYPE_NONE:
	break;
	case KEYDB_RESOURCE_TYPE_KEYBOX:
	keybox_lock (hd->active[i].u.kr, 0, 0);
	break;
	}
	}
	hd->locked = 0;
	}



	/* Push the last found state if any. Only one state is saved. */
	void
	keydb_push_found_state (KEYDB_HANDLE hd)
	{
	if (!hd)
	return;

	if (hd->use_keyboxd)
	{
	xfree (hd->kbl->saved_search_result.buf);
	hd->kbl->saved_search_result.buf = hd->kbl->search_result.buf;
	hd->kbl->saved_search_result.len = hd->kbl->search_result.len;
	hd->kbl->search_result.buf = NULL;
	hd->kbl->search_result.len = 0;
	}
	else
	{
	if (hd->found < 0 \|\| hd->found >= hd->used)
	hd->saved_found = -1;
	else
	{
	switch (hd->active[hd->found].type)
	{
	case KEYDB_RESOURCE_TYPE_NONE:
	break;
	case KEYDB_RESOURCE_TYPE_KEYBOX:
	keybox_push_found_state (hd->active[hd->found].u.kr);
	break;
	}

	hd->saved_found = hd->found;
	hd->found = -1;
	}
	}

	if (DBG_CLOCK)
	log_clock ("%s: done (hd=%p)\n", __func__, hd);
	}


	/* Pop the last found state. */
	void
	keydb_pop_found_state (KEYDB_HANDLE hd)
	{
	if (!hd)
	return;

	if (hd->use_keyboxd)
	{
	xfree (hd->kbl->search_result.buf);
	hd->kbl->search_result.buf = hd->kbl->saved_search_result.buf;
	hd->kbl->search_result.len = hd->kbl->saved_search_result.len;
	hd->kbl->saved_search_result.buf = NULL;
	hd->kbl->saved_search_result.len = 0;
	}
	else
	{
	hd->found = hd->saved_found;
	hd->saved_found = -1;
	if (hd->found < 0 \|\| hd->found >= hd->used)
	;
	else
	{
	switch (hd->active[hd->found].type)
	{
	case KEYDB_RESOURCE_TYPE_NONE:
	break;
	case KEYDB_RESOURCE_TYPE_KEYBOX:
	keybox_pop_found_state (hd->active[hd->found].u.kr);
	break;
	}
	}
	}

	if (DBG_CLOCK)
	log_clock ("%s: done (hd=%p)\n", __func__, hd);
	}



	/* Return the last found certificate. Caller must free it. */
	int
	keydb_get_cert (KEYDB_HANDLE hd, ksba_cert_t *r_cert)
	{
	int err = 0;

	if (!hd)
	return gpg_error (GPG_ERR_INV_VALUE);

	if (DBG_CLOCK)
	log_clock ("%s: enter (hd=%p)\n", __func__, hd);

	if (hd->use_keyboxd)
	{
	ksba_cert_t cert;

	/* Fixme: We should clear that also in non-keyboxd mode but we
	* did not in the past and thus all code should be checked
	* whether this is okay. If we run into error in keyboxd mode,
	* this is a not as severe because keyboxd is currently
	* experimental. */
	*r_cert = NULL;

	if (!hd->kbl->search_result.buf \|\| !hd->kbl->search_result.len)
	{
	err = gpg_error (GPG_ERR_VALUE_NOT_FOUND);
	goto leave;
	}
	err = ksba_cert_new (&cert);
	if (err)
	goto leave;
	err = ksba_cert_init_from_mem (cert,
	hd->kbl->search_result.buf,
	hd->kbl->search_result.len);
	if (err)
	{
	ksba_cert_release (cert);
	goto leave;
	}
	*r_cert = cert;
	goto leave;
	}

	if ( hd->found < 0 \|\| hd->found >= hd->used)
	{
	/* Fixme: It would be better to use GPG_ERR_VALUE_NOT_FOUND here
	* but for now we use NOT_FOUND because that is our standard
	* replacement for the formerly used (-1). */
	err = gpg_error (GPG_ERR_NOT_FOUND); /* nothing found */
	goto leave;
	}

	err = GPG_ERR_BUG;
	switch (hd->active[hd->found].type)
	{
	case KEYDB_RESOURCE_TYPE_NONE:
	err = gpg_error (GPG_ERR_GENERAL); /* oops */
	break;
	case KEYDB_RESOURCE_TYPE_KEYBOX:
	err = keybox_get_cert (hd->active[hd->found].u.kr, r_cert);
	break;
	}

	leave:
	if (DBG_CLOCK)
	log_clock ("%s: leave (rc=%d)\n", __func__, err);
	return err;
	}


	/* Return a flag of the last found object. WHICH is the flag requested;
	it should be one of the KEYBOX_FLAG_ values. If the operation is
	successful, the flag value will be stored at the address given by
	VALUE. Return 0 on success or an error code. */
	gpg_error_t
	keydb_get_flags (KEYDB_HANDLE hd, int which, int idx, unsigned int *value)
	{
	gpg_error_t err;

	if (!hd)
	return gpg_error (GPG_ERR_INV_VALUE);

	if (DBG_CLOCK)
	log_clock ("%s: enter (hd=%p)\n", __func__, hd);

	if (hd->use_keyboxd)
	{
	/* FIXME */
	*value = 0;
	err = 0;
	goto leave;
	}

	if ( hd->found < 0 \|\| hd->found >= hd->used)
	{
	err = gpg_error (GPG_ERR_NOTHING_FOUND);
	goto leave;
	}

	err = gpg_error (GPG_ERR_BUG);
	switch (hd->active[hd->found].type)
	{
	case KEYDB_RESOURCE_TYPE_NONE:
	err = gpg_error (GPG_ERR_GENERAL); /* oops */
	break;
	case KEYDB_RESOURCE_TYPE_KEYBOX:
	err = keybox_get_flags (hd->active[hd->found].u.kr, which, idx, value);
	break;
	}

	leave:
	if (DBG_CLOCK)
	log_clock ("%s: leave (err=%s)\n", __func__, gpg_strerror (err));
	return err;
	}


	/* Set a flag of the last found object. WHICH is the flag to be set; it
	should be one of the KEYBOX_FLAG_ values. If the operation is
	successful, the flag value will be stored in the keybox. Note,
	that some flag values can't be updated and thus may return an
	error, some other flag values may be masked out before an update.
	Returns 0 on success or an error code. */
	-gpg_error_t
	-keydb_set_flags (KEYDB_HANDLE hd, int which, int idx, unsigned int value)
	+static gpg_error_t
	+do_set_flags (KEYDB_HANDLE hd, int which, int idx, unsigned int value)
	{
	gpg_error_t err = 0;

	if (!hd)
	return gpg_error (GPG_ERR_INV_VALUE);

	if (DBG_CLOCK)
	log_clock ("%s: enter (hd=%p)\n", __func__, hd);

	if (hd->use_keyboxd)
	{
	/* FIXME */
	goto leave;
	}

	if ( hd->found < 0 \|\| hd->found >= hd->used)
	{
	err = gpg_error (GPG_ERR_NOTHING_FOUND);
	goto leave;
	}

	if (!hd->locked)
	{
	err = gpg_error (GPG_ERR_NOT_LOCKED);
	goto leave;
	}

	switch (hd->active[hd->found].type)
	{
	case KEYDB_RESOURCE_TYPE_NONE:
	err = gpg_error (GPG_ERR_GENERAL); /* oops */
	break;
	case KEYDB_RESOURCE_TYPE_KEYBOX:
	err = keybox_set_flags (hd->active[hd->found].u.kr, which, idx, value);
	break;
	}

	leave:
	if (DBG_CLOCK)
	log_clock ("%s: leave (err=%s)\n", __func__, gpg_strerror (err));
	return err;
	}


	/* Default status callback used to show diagnostics from the keyboxd */
	static gpg_error_t
	keydb_default_status_cb (void opaque, const char line)
	{
	const char *s;

	(void)opaque;

	if ((s = has_leading_keyword (line, "NOTE")))
	log_info (_("Note: %s\n"), s);
	else if ((s = has_leading_keyword (line, "WARNING")))
	log_info (_("WARNING: %s\n"), s);

	return 0;
	}



	/* Communication object for Keyboxd STORE commands. */
	struct store_parm_s
	{
	assuan_context_t ctx;
	const void data; / The certificate in X.509 binary format. */
	size_t datalen; /* The length of DATA. */
	};


	/* Handle the inquiries from the STORE command. */
	static gpg_error_t
	store_inq_cb (void opaque, const char line)
	{
	struct store_parm_s *parm = opaque;
	gpg_error_t err = 0;

	if (has_leading_keyword (line, "BLOB"))
	{
	if (parm->data)
	err = assuan_send_data (parm->ctx, parm->data, parm->datalen);
	}
	else
	return gpg_error (GPG_ERR_ASS_UNKNOWN_INQUIRE);

	return err;
	}


	/*
	* Insert a new Certificate into one of the resources.
	*/
	static gpg_error_t
	do_insert_cert (KEYDB_HANDLE hd, ksba_cert_t cert)
	{
	gpg_error_t err;
	int idx;
	unsigned char digest[20];

	if (!hd)
	return gpg_error (GPG_ERR_INV_VALUE);

	if (opt.dry_run)
	return 0;

	if (DBG_CLOCK)
	log_clock ("%s: enter (hd=%p)\n", __func__, hd);

	if (hd->use_keyboxd)
	{
	struct store_parm_s parm;

	parm.ctx = hd->kbl->ctx;
	parm.data = ksba_cert_get_image (cert, &parm.datalen);
	if (!parm.data)
	{
	log_debug ("broken ksba cert object\n");
	err = gpg_error (GPG_ERR_GENERAL);
	goto leave;
	}
	err = assuan_transact (hd->kbl->ctx, "STORE --insert",
	NULL, NULL,
	store_inq_cb, &parm,
	keydb_default_status_cb, hd);
	goto leave;
	}

	+ if (!hd->locked)
	+ {
	+ err = gpg_error (GPG_ERR_NOT_LOCKED);
	+ goto leave;
	+ }
	+
	if ( hd->found >= 0 && hd->found < hd->used)
	idx = hd->found;
	else if ( hd->current >= 0 && hd->current < hd->used)
	idx = hd->current;
	else
	{
	err = gpg_error (GPG_ERR_GENERAL);
	goto leave;
	}

	- if (!hd->locked)
	- {
	- err = gpg_error (GPG_ERR_NOT_LOCKED);
	- goto leave;
	- }
	-
	gpgsm_get_fingerprint (cert, GCRY_MD_SHA1, digest, NULL); /* kludge*/

	err = gpg_error (GPG_ERR_BUG);
	switch (hd->active[idx].type)
	{
	case KEYDB_RESOURCE_TYPE_NONE:
	err = gpg_error (GPG_ERR_GENERAL);
	break;
	case KEYDB_RESOURCE_TYPE_KEYBOX:
	err = keybox_insert_cert (hd->active[idx].u.kr, cert, digest);
	break;
	}

	leave:
	if (DBG_CLOCK)
	log_clock ("%s: leave (err=%s)\n", __func__, gpg_strerror (err));
	return err;
	}



	/* Update the current keyblock with KB. */
	/* Note: This function is currently not called. */
	gpg_error_t
	keydb_update_cert (KEYDB_HANDLE hd, ksba_cert_t cert)
	{
	(void)hd;
	(void)cert;
	return GPG_ERR_BUG;
	#if 0
	gpg_error_t err;
	unsigned char digest[20];

	if (!hd)
	return gpg_error (GPG_ERR_INV_VALUE);

	+ if (hd->use_keyboxd)
	+ {
	+ /* FIXME */
	+ goto leave;
	+ }
	+
	+ if (!hd->locked)
	+ {
	+ err = gpg_error (GPG_ERR_NOT_LOCKED);
	+ goto leave;
	+ }
	+
	if ( hd->found < 0 \|\| hd->found >= hd->used)
	return gpg_error (GPG_ERR_NOT_FOUND);

	if (opt.dry_run)
	return 0;

	if (DBG_CLOCK)
	log_clock ("%s: enter (hd=%p)\n", __func__, hd);

	- if (hd->use_keyboxd)
	- {
	- /* FIXME */
	- goto leave;
	- }
	-
	- err = lock_all (hd);
	- if (err)
	- goto leave;
	-
	gpgsm_get_fingerprint (cert, GCRY_MD_SHA1, digest, NULL); /* kludge*/

	err = gpg_error (GPG_ERR_BUG);
	switch (hd->active[hd->found].type)
	{
	case KEYDB_RESOURCE_TYPE_NONE:
	err = gpg_error (GPG_ERR_GENERAL); /* oops */
	break;
	case KEYDB_RESOURCE_TYPE_KEYBOX:
	err = keybox_update_cert (hd->active[hd->found].u.kr, cert, digest);
	break;
	}

	- unlock_all (hd);
	leave:
	if (DBG_CLOCK)
	log_clock ("%s: leave (err=%s)\n", __func__, gpg_strerror (err));
	return err;
	#endif /0/
	}


	/*
	* The current keyblock or cert will be deleted.
	*/
	gpg_error_t
	keydb_delete (KEYDB_HANDLE hd)
	{
	gpg_error_t err;

	if (!hd)
	return gpg_error (GPG_ERR_INV_VALUE);

	if (!hd->use_keyboxd && (hd->found < 0 \|\| hd->found >= hd->used))
	return gpg_error (GPG_ERR_NOT_FOUND);

	if (opt.dry_run)
	return 0;

	if (DBG_CLOCK)
	log_clock ("%s: enter (hd=%p)\n", __func__, hd);

	if (hd->use_keyboxd)
	{
	unsigned char hexubid[UBID_LEN * 2 + 1];
	char line[ASSUAN_LINELENGTH];

	if (!hd->last_ubid_valid)
	{
	err = gpg_error (GPG_ERR_VALUE_NOT_FOUND);
	goto leave;
	}

	bin2hex (hd->last_ubid, UBID_LEN, hexubid);
	snprintf (line, sizeof line, "DELETE %s", hexubid);
	err = assuan_transact (hd->kbl->ctx, line,
	NULL, NULL,
	NULL, NULL,
	keydb_default_status_cb, hd);
	goto leave;
	}

	if (!hd->locked)
	{
	err = gpg_error (GPG_ERR_NOT_LOCKED);
	goto leave;
	}

	err = gpg_error (GPG_ERR_BUG);
	switch (hd->active[hd->found].type)
	{
	case KEYDB_RESOURCE_TYPE_NONE:
	err = gpg_error (GPG_ERR_GENERAL);
	break;
	case KEYDB_RESOURCE_TYPE_KEYBOX:
	err = keybox_delete (hd->active[hd->found].u.kr);
	break;
	}

	leave:
	if (DBG_CLOCK)
	log_clock ("%s: leave (err=%s)\n", __func__, gpg_strerror (err));
	return err;
	}



	/*
	* Locate the default writable key resource, so that the next
	* operation (which is only relevant for inserts) will be done on this
	* resource.
	*/
	static gpg_error_t
	keydb_locate_writable (KEYDB_HANDLE hd, const char *reserved)
	{
	int rc;

	(void)reserved;

	if (!hd)
	return gpg_error (GPG_ERR_INV_VALUE);

	if (hd->use_keyboxd)
	return 0; /* Not required. */

	rc = keydb_search_reset (hd); /* this does reset hd->current */
	if (rc)
	return rc;

	for ( ; hd->current >= 0 && hd->current < hd->used; hd->current++)
	{
	switch (hd->active[hd->current].type)
	{
	case KEYDB_RESOURCE_TYPE_NONE:
	BUG();
	break;
	case KEYDB_RESOURCE_TYPE_KEYBOX:
	if (keybox_is_writable (hd->active[hd->current].token))
	return 0; /* found (hd->current is set to it) */
	break;
	}
	}

	return gpg_error (GPG_ERR_NOT_FOUND);
	}

	/*
	* Rebuild the caches of all key resources.
	*/
	void
	keydb_rebuild_caches (void)
	{
	int i;

	/* This function does nothing and thus we don't need to handle keyboxd in a
	* special way. */

	for (i=0; i < used_resources; i++)
	{
	switch (all_resources[i].type)
	{
	case KEYDB_RESOURCE_TYPE_NONE: /* ignore */
	break;
	case KEYDB_RESOURCE_TYPE_KEYBOX:
	/* rc = keybox_rebuild_cache (all_resources[i].token); */
	/* if (rc) */
	/* log_error (_("failed to rebuild keybox cache: %s\n"), */
	/* g10_errstr (rc)); */
	break;
	}
	}
	}



	/*
	* Start the next search on this handle right at the beginning
	*/
	gpg_error_t
	keydb_search_reset (KEYDB_HANDLE hd)
	{
	gpg_error_t err = 0;
	int i;

	if (!hd)
	return gpg_error (GPG_ERR_INV_VALUE);

	if (DBG_CLOCK)
	log_clock ("%s: enter (hd=%p)\n", __func__, hd);

	hd->current = 0;
	hd->found = -1;
	if (hd->use_keyboxd)
	{
	/* All we need is to tell search that a reset is pending. Note that
	* keydb_new sets this flag as well. To comply with the
	* specification of keydb_delete_keyblock we also need to clear the
	* ubid flag so that after a reset a delete can't be performed. */
	hd->kbl->need_search_reset = 1;
	hd->last_ubid_valid = 0;
	}
	else
	{
	/* Reset all resources */
	for (i=0; !err && i < hd->used; i++)
	{
	switch (hd->active[i].type)
	{
	case KEYDB_RESOURCE_TYPE_NONE:
	break;
	case KEYDB_RESOURCE_TYPE_KEYBOX:
	err = keybox_search_reset (hd->active[i].u.kr);
	break;
	}
	}
	}

	if (DBG_CLOCK)
	log_clock ("%s: leave (err=%s)\n", __func__, gpg_strerror (err));
	return err;
	}


	char *
	keydb_search_desc_dump (struct keydb_search_desc *desc)
	{
	char *fpr;
	char *result;

	switch (desc->mode)
	{
	case KEYDB_SEARCH_MODE_EXACT:
	return xasprintf ("EXACT: '%s'", desc->u.name);
	case KEYDB_SEARCH_MODE_SUBSTR:
	return xasprintf ("SUBSTR: '%s'", desc->u.name);
	case KEYDB_SEARCH_MODE_MAIL:
	return xasprintf ("MAIL: '%s'", desc->u.name);
	case KEYDB_SEARCH_MODE_MAILSUB:
	return xasprintf ("MAILSUB: '%s'", desc->u.name);
	case KEYDB_SEARCH_MODE_MAILEND:
	return xasprintf ("MAILEND: '%s'", desc->u.name);
	case KEYDB_SEARCH_MODE_WORDS:
	return xasprintf ("WORDS: '%s'", desc->u.name);
	case KEYDB_SEARCH_MODE_SHORT_KID:
	return xasprintf ("SHORT_KID: '%08lX'", (ulong)desc->u.kid[1]);
	case KEYDB_SEARCH_MODE_LONG_KID:
	return xasprintf ("LONG_KID: '%08lX%08lX'",
	(ulong)desc->u.kid[0], (ulong)desc->u.kid[1]);
	case KEYDB_SEARCH_MODE_FPR:
	fpr = bin2hexcolon (desc->u.fpr, desc->fprlen, NULL);
	result = xasprintf ("FPR%02d: '%s'", desc->fprlen, fpr);
	xfree (fpr);
	return result;
	case KEYDB_SEARCH_MODE_ISSUER:
	return xasprintf ("ISSUER: '%s'", desc->u.name);
	case KEYDB_SEARCH_MODE_ISSUER_SN:
	return xasprintf ("ISSUER_SN: '#%.*s/%s'",
	(int)desc->snlen,desc->sn, desc->u.name);
	case KEYDB_SEARCH_MODE_SN:
	return xasprintf ("SN: '%.*s'",
	(int)desc->snlen, desc->sn);
	case KEYDB_SEARCH_MODE_SUBJECT:
	return xasprintf ("SUBJECT: '%s'", desc->u.name);
	case KEYDB_SEARCH_MODE_KEYGRIP:
	return xasprintf ("KEYGRIP: %s", desc->u.grip);
	case KEYDB_SEARCH_MODE_FIRST:
	return xasprintf ("FIRST");
	case KEYDB_SEARCH_MODE_NEXT:
	return xasprintf ("NEXT");
	default:
	return xasprintf ("Bad search mode (%d)", desc->mode);
	}
	}



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

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

	return err;
	}

	/* Search through all keydb resources, starting at the current
	* position, for a keyblock which contains one of the keys described
	* in the DESC array. In keyboxd mode the search is instead delegated
	* to the keyboxd.
	*
	* DESC is an array of search terms with NDESC entries. The search
	* terms are or'd together. That is, the next entry in the DB that
	* matches any of the descriptions will be returned.
	*
	* Note: this function resumes searching where the last search left
	* off (i.e., at the current file position). If you want to search
	* from the start of the database, then you need to first call
	* keydb_search_reset().
	*
	* If no key matches the search description, the error code
	* GPG_ERR_NOT_FOUND is returned. If there was a match, 0 is
	* returned. If an error occurred, that error code is returned.
	*
	* The returned key is considered to be selected and the certificate
	* can be detched via keydb_get_cert. */
	gpg_error_t
	keydb_search (ctrl_t ctrl, KEYDB_HANDLE hd,
	KEYDB_SEARCH_DESC *desc, size_t ndesc)
	{
	gpg_error_t err = gpg_error (GPG_ERR_EOF);
	unsigned long skipped = 0;
	int i;

	if (!hd)
	return gpg_error (GPG_ERR_INV_VALUE);

	if (!any_registered && !hd->use_keyboxd)
	{
	gpgsm_status_with_error (ctrl, STATUS_ERROR, "keydb_search",
	gpg_error (GPG_ERR_KEYRING_OPEN));
	return gpg_error (GPG_ERR_NOT_FOUND);
	}

	if (DBG_CLOCK)
	log_clock ("%s: enter (hd=%p)\n", __func__, hd);

	if (DBG_LOOKUP)
	{
	log_debug ("%s: %zd search description(s):\n", __func__, ndesc);
	for (i = 0; i < ndesc; i ++)
	{
	char *t = keydb_search_desc_dump (&desc[i]);
	log_debug ("%s: %d: %s\n", __func__, i, t);
	xfree (t);
	}
	}

	if (hd->use_keyboxd)
	{
	char line[ASSUAN_LINELENGTH];

	/* Clear the result objects. */
	if (hd->kbl->search_result.buf)
	{
	xfree (hd->kbl->search_result.buf);
	hd->kbl->search_result.buf = NULL;
	hd->kbl->search_result.len = 0;
	}

	/* Check whether this is a NEXT search. */
	if (!hd->kbl->need_search_reset)
	{
	/* A reset was not requested thus continue the search. The
	* keyboxd keeps the context of the search and thus the NEXT
	* operates on the last search pattern. This is the way how
	* we always used the keydb functions. In theory we were
	* able to modify the search pattern between searches but
	* that is not anymore supported by keyboxd and a cursory
	* check does not show that we actually made use of that
	* misfeature. */
	snprintf (line, sizeof line, "NEXT --x509");
	goto do_search;
	}

	hd->kbl->need_search_reset = 0;

	if (!ndesc)
	{
	err = gpg_error (GPG_ERR_INV_ARG);
	goto leave;
	}

	/* FIXME: Implement --multi */
	switch (desc->mode)
	{
	case KEYDB_SEARCH_MODE_EXACT:
	snprintf (line, sizeof line, "SEARCH --x509 =%s", desc[0].u.name);
	break;

	case KEYDB_SEARCH_MODE_SUBSTR:
	snprintf (line, sizeof line, "SEARCH --x509 *%s", desc[0].u.name);
	break;

	case KEYDB_SEARCH_MODE_MAIL:
	snprintf (line, sizeof line, "SEARCH --x509 <%s",
	desc[0].u.name + (desc[0].u.name[0] == '<'));
	break;

	case KEYDB_SEARCH_MODE_MAILSUB:
	snprintf (line, sizeof line, "SEARCH --x509 @%s", desc[0].u.name);
	break;

	case KEYDB_SEARCH_MODE_MAILEND:
	snprintf (line, sizeof line, "SEARCH --x509 .%s", desc[0].u.name);
	break;

	case KEYDB_SEARCH_MODE_WORDS:
	snprintf (line, sizeof line, "SEARCH --x509 +%s", desc[0].u.name);
	break;

	case KEYDB_SEARCH_MODE_SHORT_KID:
	snprintf (line, sizeof line, "SEARCH --x509 0x%08lX",
	(ulong)desc->u.kid[1]);
	break;

	case KEYDB_SEARCH_MODE_LONG_KID:
	snprintf (line, sizeof line, "SEARCH --x509 0x%08lX%08lX",
	(ulong)desc->u.kid[0], (ulong)desc->u.kid[1]);
	break;

	case KEYDB_SEARCH_MODE_FPR:
	{
	unsigned char hexfpr[MAX_FINGERPRINT_LEN * 2 + 1];
	log_assert (desc[0].fprlen <= MAX_FINGERPRINT_LEN);
	bin2hex (desc[0].u.fpr, desc[0].fprlen, hexfpr);
	snprintf (line, sizeof line, "SEARCH --x509 0x%s", hexfpr);
	}
	break;

	case KEYDB_SEARCH_MODE_ISSUER:
	snprintf (line, sizeof line, "SEARCH --x509 #/%s", desc[0].u.name);
	break;

	case KEYDB_SEARCH_MODE_ISSUER_SN:
	if (desc[0].snhex)
	snprintf (line, sizeof line, "SEARCH --x509 #%.*s/%s",
	(int)desc[0].snlen, desc[0].sn, desc[0].u.name);
	else
	{
	char *hexsn = bin2hex (desc[0].sn, desc[0].snlen, NULL);
	if (!hexsn)
	{
	err = gpg_error_from_syserror ();
	goto leave;
	}
	snprintf (line, sizeof line, "SEARCH --x509 #%s/%s",
	hexsn, desc[0].u.name);
	xfree (hexsn);
	}
	break;

	case KEYDB_SEARCH_MODE_SN:
	snprintf (line, sizeof line, "SEARCH --x509 #%s", desc[0].u.name);
	break;

	case KEYDB_SEARCH_MODE_SUBJECT:
	snprintf (line, sizeof line, "SEARCH --x509 /%s", desc[0].u.name);
	break;

	case KEYDB_SEARCH_MODE_KEYGRIP:
	{
	unsigned char hexgrip[KEYGRIP_LEN * 2 + 1];
	bin2hex (desc[0].u.grip, KEYGRIP_LEN, hexgrip);
	snprintf (line, sizeof line, "SEARCH --x509 &%s", hexgrip);
	}
	break;

	case KEYDB_SEARCH_MODE_UBID:
	{
	unsigned char hexubid[UBID_LEN * 2 + 1];
	bin2hex (desc[0].u.ubid, UBID_LEN, hexubid);
	snprintf (line, sizeof line, "SEARCH --x509 ^%s", hexubid);
	}
	break;

	case KEYDB_SEARCH_MODE_FIRST:
	snprintf (line, sizeof line, "SEARCH --x509");
	break;

	case KEYDB_SEARCH_MODE_NEXT:
	log_debug ("%s: mode next - we should not get to here!\n", __func__);
	snprintf (line, sizeof line, "NEXT --x509");
	break;

	default:
	err = gpg_error (GPG_ERR_INV_ARG);
	goto leave;
	}

	do_search:
	hd->last_ubid_valid = 0;
	/* To avoid silent truncation we error out on a too long line. */
	if (strlen (line) + 5 >= sizeof line)
	err = gpg_error (GPG_ERR_ASS_LINE_TOO_LONG);
	else
	err = kbx_client_data_cmd (hd->kbl->kcd, line, search_status_cb, hd);
	if (!err && !(err = kbx_client_data_wait (hd->kbl->kcd,
	&hd->kbl->search_result.buf,
	&hd->kbl->search_result.len)))
	{
	/* if (hd->last_ubid_valid) */
	/* log_printhex (hd->last_ubid, 20, "found UBID%s:", */
	/* hd->last_is_ephemeral? "(ephemeral)":""); */
	}

	}
	else /* Local keyring search. */
	{
	while (gpg_err_code (err) == GPG_ERR_EOF
	&& hd->current >= 0 && hd->current < hd->used)
	{
	switch (hd->active[hd->current].type)
	{
	case KEYDB_RESOURCE_TYPE_NONE:
	BUG(); /* we should never see it here */
	break;
	case KEYDB_RESOURCE_TYPE_KEYBOX:
	err = keybox_search (hd->active[hd->current].u.kr, desc, ndesc,
	KEYBOX_BLOBTYPE_X509,
	NULL, &skipped);
	if (err == -1) /* Map legacy code. */
	err = gpg_error (GPG_ERR_EOF);
	break;
	}

	if (DBG_LOOKUP)
	log_debug ("%s: searched %s (resource %d of %d) => %s\n",
	__func__,
	hd->active[hd->current].type==KEYDB_RESOURCE_TYPE_KEYBOX
	? "keybox" : "unknown type",
	hd->current, hd->used, gpg_strerror (err));

	if (gpg_err_code (err) == GPG_ERR_EOF)
	{ /* EOF -> switch to next resource */
	hd->current++;
	}
	else if (!err)
	hd->found = hd->current;
	}
	}

	leave:
	/* The NOTHING_FOUND error is triggered by a NEXT command. */
	if (gpg_err_code (err) == GPG_ERR_EOF
	\|\| gpg_err_code (err) == GPG_ERR_NOTHING_FOUND)
	err = gpg_error (GPG_ERR_NOT_FOUND);
	if (DBG_CLOCK)
	log_clock ("%s: leave (%s)\n", __func__, gpg_strerror (err));
	return err;
	}


	int
	keydb_search_first (ctrl_t ctrl, KEYDB_HANDLE hd)
	{
	KEYDB_SEARCH_DESC desc;

	memset (&desc, 0, sizeof desc);
	desc.mode = KEYDB_SEARCH_MODE_FIRST;
	return keydb_search (ctrl, hd, &desc, 1);
	}

	int
	keydb_search_next (ctrl_t ctrl, KEYDB_HANDLE hd)
	{
	KEYDB_SEARCH_DESC desc;

	memset (&desc, 0, sizeof desc);
	desc.mode = KEYDB_SEARCH_MODE_NEXT;
	return keydb_search (ctrl, hd, &desc, 1);
	}

	int
	keydb_search_kid (ctrl_t ctrl, KEYDB_HANDLE hd, u32 *kid)
	{
	KEYDB_SEARCH_DESC desc;

	(void)kid;

	memset (&desc, 0, sizeof desc);
	desc.mode = KEYDB_SEARCH_MODE_LONG_KID;
	desc.u.kid[0] = kid[0];
	desc.u.kid[1] = kid[1];
	return keydb_search (ctrl, hd, &desc, 1);
	}

	int
	keydb_search_fpr (ctrl_t ctrl, KEYDB_HANDLE hd, const byte *fpr)
	{
	KEYDB_SEARCH_DESC desc;

	memset (&desc, 0, sizeof desc);
	desc.mode = KEYDB_SEARCH_MODE_FPR;
	memcpy (desc.u.fpr, fpr, 20);
	desc.fprlen = 20;
	return keydb_search (ctrl, hd, &desc, 1);
	}

	int
	keydb_search_issuer (ctrl_t ctrl, KEYDB_HANDLE hd, const char *issuer)
	{
	KEYDB_SEARCH_DESC desc;
	int rc;

	memset (&desc, 0, sizeof desc);
	desc.mode = KEYDB_SEARCH_MODE_ISSUER;
	desc.u.name = issuer;
	rc = keydb_search (ctrl, hd, &desc, 1);
	return rc;
	}

	int
	keydb_search_issuer_sn (ctrl_t ctrl, KEYDB_HANDLE hd,
	const char *issuer, ksba_const_sexp_t serial)
	{
	KEYDB_SEARCH_DESC desc;
	int rc;
	const unsigned char *s;

	memset (&desc, 0, sizeof desc);
	desc.mode = KEYDB_SEARCH_MODE_ISSUER_SN;
	s = serial;
	if (*s !='(')
	return gpg_error (GPG_ERR_INV_VALUE);
	s++;
	for (desc.snlen = 0; digitp (s); s++)
	desc.snlen = 10*desc.snlen + atoi_1 (s);
	if (*s !=':')
	return gpg_error (GPG_ERR_INV_VALUE);
	desc.sn = s+1;
	desc.u.name = issuer;
	rc = keydb_search (ctrl, hd, &desc, 1);
	return rc;
	}

	int
	keydb_search_subject (ctrl_t ctrl, KEYDB_HANDLE hd, const char *name)
	{
	KEYDB_SEARCH_DESC desc;
	int rc;

	memset (&desc, 0, sizeof desc);
	desc.mode = KEYDB_SEARCH_MODE_SUBJECT;
	desc.u.name = name;
	rc = keydb_search (ctrl, hd, &desc, 1);
	return rc;
	}



	/* Store the certificate in the key DB but make sure that it does not
	already exists. We do this simply by comparing the fingerprint.
	If EXISTED is not NULL it will be set to true if the certificate
	was already in the DB. */
	int
	keydb_store_cert (ctrl_t ctrl, ksba_cert_t cert, int ephemeral, int *existed)
	{
	KEYDB_HANDLE kh;
	int rc;
	unsigned char fpr[20];

	if (existed)
	*existed = 0;

	if (!gpgsm_get_fingerprint (cert, 0, fpr, NULL))
	{
	log_error (_("failed to get the fingerprint\n"));
	return gpg_error (GPG_ERR_GENERAL);
	}

	kh = keydb_new (ctrl);
	if (!kh)
	{
	log_error (_("failed to allocate keyDB handle\n"));
	return gpg_error (GPG_ERR_ENOMEM);;
	}

	/* Set the ephemeral flag so that the search looks at all
	records. */
	keydb_set_ephemeral (kh, 1);

	if (!kh->use_keyboxd)
	{
	rc = keydb_lock (kh);
	if (rc)
	return rc;
	}

	rc = keydb_search_fpr (ctrl, kh, fpr);
	if (gpg_err_code (rc) != GPG_ERR_NOT_FOUND)
	{
	keydb_release (kh);
	if (!rc)
	{
	if (existed)
	*existed = 1;
	if (!ephemeral)
	{
	/* Remove ephemeral flags from existing certificate to "store"
	it permanently. */
	rc = keydb_set_cert_flags (ctrl, cert, 1, KEYBOX_FLAG_BLOB, 0,
	KEYBOX_FLAG_BLOB_EPHEMERAL, 0);
	if (rc)
	{
	log_error ("clearing ephemeral flag failed: %s\n",
	gpg_strerror (rc));
	return rc;
	}
	}
	return 0; /* okay */
	}
	log_error (_("problem looking for existing certificate: %s\n"),
	gpg_strerror (rc));
	return rc;
	}

	/* Reset the ephemeral flag if not requested. */
	if (!ephemeral)
	keydb_set_ephemeral (kh, 0);

	rc = keydb_locate_writable (kh, 0);
	if (rc)
	{
	log_error (_("error finding writable keyDB: %s\n"), gpg_strerror (rc));
	keydb_release (kh);
	return rc;
	}

	rc = do_insert_cert (kh, cert);
	if (rc)
	{
	log_error (_("error storing certificate: %s\n"), gpg_strerror (rc));
	keydb_release (kh);
	return rc;
	}
	keydb_release (kh);
	return 0;
	}


	-/* This is basically keydb_set_flags but it implements a complete
	+/* This is basically do_set_flags but it implements a complete
	transaction by locating the certificate in the DB and updating the
	flags. */
	gpg_error_t
	keydb_set_cert_flags (ctrl_t ctrl, ksba_cert_t cert, int ephemeral,
	int which, int idx,
	unsigned int mask, unsigned int value)
	{
	KEYDB_HANDLE kh;
	gpg_error_t err;
	unsigned char fpr[20];
	unsigned int old_value;

	if (!gpgsm_get_fingerprint (cert, 0, fpr, NULL))
	{
	log_error (_("failed to get the fingerprint\n"));
	return gpg_error (GPG_ERR_GENERAL);
	}

	kh = keydb_new (ctrl);
	if (!kh)
	{
	log_error (_("failed to allocate keyDB handle\n"));
	return gpg_error (GPG_ERR_ENOMEM);;
	}

	if (ephemeral)
	keydb_set_ephemeral (kh, 1);

	if (!kh->use_keyboxd)
	{
	err = keydb_lock (kh);
	if (err)
	{
	log_error (_("error locking keybox: %s\n"), gpg_strerror (err));
	keydb_release (kh);
	return err;
	}
	}

	err = keydb_search_fpr (ctrl, kh, fpr);
	if (err)
	{
	if (gpg_err_code (err) != GPG_ERR_NOT_FOUND)
	log_error (_("problem re-searching certificate: %s\n"),
	gpg_strerror (err));
	keydb_release (kh);
	return err;
	}

	err = keydb_get_flags (kh, which, idx, &old_value);
	if (err)
	{
	log_error (_("error getting stored flags: %s\n"), gpg_strerror (err));
	keydb_release (kh);
	return err;
	}

	value = ((old_value & ~mask) \| (value & mask));

	if (value != old_value)
	{
	- err = keydb_set_flags (kh, which, idx, value);
	+ err = do_set_flags (kh, which, idx, value);
	if (err)
	{
	log_error (_("error storing flags: %s\n"), gpg_strerror (err));
	keydb_release (kh);
	return err;
	}
	}

	keydb_release (kh);
	return 0;
	}


	/* Reset all the certificate flags we have stored with the certificates
	for performance reasons. */
	void
	keydb_clear_some_cert_flags (ctrl_t ctrl, strlist_t names)
	{
	gpg_error_t err;
	KEYDB_HANDLE hd = NULL;
	KEYDB_SEARCH_DESC *desc = NULL;
	int ndesc;
	strlist_t sl;
	int rc=0;
	unsigned int old_value, value;

	(void)ctrl;

	hd = keydb_new (ctrl);
	if (!hd)
	{
	log_error ("keydb_new failed\n");
	goto leave;
	}

	if (!names)
	ndesc = 1;
	else
	{
	for (sl=names, ndesc=0; sl; sl = sl->next, ndesc++)
	;
	}

	desc = xtrycalloc (ndesc, sizeof *desc);
	if (!ndesc)
	{
	log_error ("allocating memory failed: %s\n",
	gpg_strerror (out_of_core ()));
	goto leave;
	}

	if (!names)
	desc[0].mode = KEYDB_SEARCH_MODE_FIRST;
	else
	{
	for (ndesc=0, sl=names; sl; sl = sl->next)
	{
	rc = classify_user_id (sl->d, desc+ndesc, 0);
	if (rc)
	log_error ("key '%s' not found: %s\n", sl->d, gpg_strerror (rc));
	else
	ndesc++;
	}
	}

	if (!hd->use_keyboxd)
	{
	err = keydb_lock (hd);
	if (err)
	{
	log_error (_("error locking keybox: %s\n"), gpg_strerror (err));
	goto leave;
	}
	}

	while (!(rc = keydb_search (ctrl, hd, desc, ndesc)))
	{
	if (!names)
	desc[0].mode = KEYDB_SEARCH_MODE_NEXT;

	err = keydb_get_flags (hd, KEYBOX_FLAG_VALIDITY, 0, &old_value);
	if (err)
	{
	log_error (_("error getting stored flags: %s\n"),
	gpg_strerror (err));
	goto leave;
	}

	value = (old_value & ~VALIDITY_REVOKED);
	if (value != old_value)
	{
	- err = keydb_set_flags (hd, KEYBOX_FLAG_VALIDITY, 0, value);
	+ err = do_set_flags (hd, KEYBOX_FLAG_VALIDITY, 0, value);
	if (err)
	{
	log_error (_("error storing flags: %s\n"), gpg_strerror (err));
	goto leave;
	}
	}
	}
	if (rc && gpg_err_code (rc) != GPG_ERR_NOT_FOUND)
	log_error ("keydb_search failed: %s\n", gpg_strerror (rc));

	leave:
	xfree (desc);
	keydb_release (hd);
	}
	diff --git a/sm/keydb.h b/sm/keydb.h
	index 2725cadc6..8c453f9cd 100644
	--- a/sm/keydb.h
	+++ b/sm/keydb.h
	@@ -1,78 +1,76 @@
	/* keydb.h - Key database
	* Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
	*
	* This file is part of GnuPG.
	*
	* GnuPG is free software; you can redistribute it and/or modify
	* it under the terms of the GNU General Public License as published by
	* the Free Software Foundation; either version 3 of the License, or
	* (at your option) any later version.
	*
	* GnuPG is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with this program; if not, see <https://www.gnu.org/licenses/>.
	*/

	#ifndef GNUPG_KEYDB_H
	#define GNUPG_KEYDB_H

	#include <ksba.h>

	#include "../common/userids.h"

	typedef struct keydb_handle *KEYDB_HANDLE;

	/* Flag value used with KEYBOX_FLAG_VALIDITY. */
	#define VALIDITY_REVOKED (1<<5)


	/-- keydb.c --/
	void gpgsm_keydb_deinit_session_data (ctrl_t ctrl);
	gpg_error_t keydb_add_resource (ctrl_t ctrl, const char *url,
	int force, int *auto_created);
	KEYDB_HANDLE keydb_new (ctrl_t ctrl);
	void keydb_release (KEYDB_HANDLE hd);
	int keydb_set_ephemeral (KEYDB_HANDLE hd, int yes);
	const char *keydb_get_resource_name (KEYDB_HANDLE hd);
	gpg_error_t keydb_lock (KEYDB_HANDLE hd);

	gpg_error_t keydb_get_flags (KEYDB_HANDLE hd, int which, int idx,
	unsigned int *value);
	-gpg_error_t keydb_set_flags (KEYDB_HANDLE hd, int which, int idx,
	- unsigned int value);
	void keydb_push_found_state (KEYDB_HANDLE hd);
	void keydb_pop_found_state (KEYDB_HANDLE hd);
	int keydb_get_cert (KEYDB_HANDLE hd, ksba_cert_t *r_cert);
	gpg_error_t keydb_insert_cert (KEYDB_HANDLE hd, ksba_cert_t cert);
	gpg_error_t keydb_update_cert (KEYDB_HANDLE hd, ksba_cert_t cert);

	gpg_error_t keydb_delete (KEYDB_HANDLE hd);

	void keydb_rebuild_caches (void);

	gpg_error_t keydb_search_reset (KEYDB_HANDLE hd);
	gpg_error_t keydb_search (ctrl_t ctrl, KEYDB_HANDLE hd,
	KEYDB_SEARCH_DESC *desc, size_t ndesc);
	int keydb_search_first (ctrl_t ctrl, KEYDB_HANDLE hd);
	int keydb_search_next (ctrl_t ctrl, KEYDB_HANDLE hd);
	int keydb_search_kid (ctrl_t ctrl, KEYDB_HANDLE hd, u32 *kid);
	int keydb_search_fpr (ctrl_t ctrl, KEYDB_HANDLE hd, const byte *fpr);
	int keydb_search_issuer (ctrl_t ctrl, KEYDB_HANDLE hd, const char *issuer);
	int keydb_search_issuer_sn (ctrl_t ctrl, KEYDB_HANDLE hd,
	const char issuer, const unsigned char serial);
	int keydb_search_subject (ctrl_t ctrl, KEYDB_HANDLE hd, const char *issuer);

	int keydb_store_cert (ctrl_t ctrl, ksba_cert_t cert, int ephemeral,
	int *existed);
	gpg_error_t keydb_set_cert_flags (ctrl_t ctrl, ksba_cert_t cert, int ephemeral,
	int which, int idx,
	unsigned int mask, unsigned int value);

	void keydb_clear_some_cert_flags (ctrl_t ctrl, strlist_t names);


	#endif /GNUPG_KEYDB_H/

File Metadata

Mime Type: text/x-diff
Expires: Sat, Dec 6, 10:42 PM (1 d, 16 h)
Storage Engine: local-disk
Storage Format: Raw Data
Storage Handle: f8/a6/c7edb35192c54e76e632e7d88b7d

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions