No OneTemporary
Actions

Size

78 KB

Subscribers

None

View Options

	diff --git a/doc/gpgv.texi b/doc/gpgv.texi
	index 8d7164ae0..6bcbc0add 100644
	--- a/doc/gpgv.texi
	+++ b/doc/gpgv.texi
	@@ -1,170 +1,171 @@
	@c Copyright (C) 2004 Free Software Foundation, Inc.
	@c This is part of the GnuPG manual.
	@c For copying conditions, see the file GnuPG.texi.

	@c
	@c This is included by tools.texi.
	@c

	@include defs.inc

	@c Begin GnuPG 1.x specific stuff
	@ifset gpgone
	@macro gpgvname
	gpgv
	@end macro
	@manpage gpgv.1
	@node gpgv
	@section Verify OpenPGP signatures
	@ifset manverb
	.B gpgv
	\- Verify OpenPGP signatures
	@end ifset

	@mansect synopsis
	@ifset manverb
	.B gpgv
	.RI [ options ]
	.I signed_files
	@end ifset
	@end ifset
	@c End GnuPG 1.x specific stuff

	@c Begin GnuPG 2 specific stuff
	@ifclear gpgone
	@macro gpgvname
	gpgv2
	@end macro
	@manpage gpgv2.1
	@node gpgv
	@section Verify OpenPGP signatures
	@ifset manverb
	.B gpgv2
	\- Verify OpenPGP signatures
	@end ifset

	@mansect synopsis
	@ifset manverb
	.B gpgv2
	.RI [ options ]
	.I signed_files
	@end ifset
	@end ifclear
	@c End GnuPG 2 specific stuff



	@mansect description
	@code{@gpgvname} is an OpenPGP signature verification tool.

	This program is actually a stripped-down version of @code{gpg} which is
	only able to check signatures. It is somewhat smaller than the fully-blown
	@code{gpg} and uses a different (and simpler) way to check that
	the public keys used to make the signature are valid. There are
	no configuration files and only a few options are implemented.

	@code{@gpgvname} assumes that all keys in the keyring are trustworthy.
	That does also mean that it does not check for expired or revoked
	keys.

	-By default a keyring named @file{trustedkeys.gpg} is used. This
	+By default a keyring named @file{trustedkeys.kbx} is used; if that
	+does not exist a keyring named @file{trustedkeys.gpg} is used. The
	default keyring is assumed to be in the home directory of GnuPG,
	either the default home directory or the one set by an option or an
	environment variable. The option @code{--keyring} may be used to
	specify a different keyring or even multiple keyrings.


	@noindent
	@mansect options
	@code{@gpgvname} recognizes these options:

	@table @gnupgtabopt

	@item --verbose
	@itemx -v
	@opindex verbose
	Gives more information during processing. If used
	twice, the input data is listed in detail.

	@item --quiet
	@itemx -q
	@opindex quiet
	Try to be as quiet as possible.

	@item --keyring @var{file}
	@opindex keyring
	Add @var{file} to the list of keyrings.
	If @var{file} begins with a tilde and a slash, these
	are replaced by the HOME directory. If the filename
	does not contain a slash, it is assumed to be in the
	home-directory ("~/.gnupg" if --homedir is not used).

	@item --status-fd @var{n}
	@opindex status-fd
	Write special status strings to the file descriptor @var{n}. See the
	file DETAILS in the documentation for a listing of them.

	@item --logger-fd @code{n}
	@opindex logger-fd
	Write log output to file descriptor @code{n} and not to stderr.

	@item --ignore-time-conflict
	@opindex ignore-time-conflict
	GnuPG normally checks that the timestamps associated with keys and
	signatures have plausible values. However, sometimes a signature seems to
	be older than the key due to clock problems. This option turns these
	checks into warnings.

	@include opt-homedir.texi

	@end table

	@mansect return value

	The program returns 0 if everything is fine, 1 if at least
	one signature was bad, and other error codes for fatal errors.

	@mansect examples
	@subsection Examples

	@table @asis

	@item @gpgvname @code{pgpfile}
	@itemx @gpgvname @code{sigfile} [@code{datafile}]
	Verify the signature of the file. The second form is used for detached
	signatures, where @code{sigfile} is the detached signature (either
	ASCII-armored or binary) and @code{datafile} contains the signed data;
	if @code{datafile} is "-" the signed data is expected on
	@code{stdin}; if @code{datafile} is not given the name of the file
	holding the signed data is constructed by cutting off the extension
	(".asc", ".sig" or ".sign") from @code{sigfile}.

	@end table

	@mansect environment
	@subsection Environment

	@table @asis

	@item HOME
	Used to locate the default home directory.

	@item GNUPGHOME
	If set directory used instead of "~/.gnupg".

	@end table

	@mansect files
	@subsection FILES

	@table @asis

	@item ~/.gnupg/trustedkeys.gpg
	The default keyring with the allowed keys.

	@end table

	@mansect see also
	@command{gpg2}(1)
	@include see-also-note.texi

	diff --git a/g10/gpgv.c b/g10/gpgv.c
	index 479bb9599..412f4bee3 100644
	--- a/g10/gpgv.c
	+++ b/g10/gpgv.c
	@@ -1,593 +1,594 @@
	/* gpgv.c - The GnuPG signature verify utility
	* Copyright (C) 1998, 1999, 2000, 2001, 2002, 2005, 2006,
	* 2008, 2009, 2012 Free Software Foundation, Inc.
	*
	* This file is part of GnuPG.
	*
	* GnuPG is free software; you can redistribute it and/or modify
	* it under the terms of the GNU General Public License as published by
	* the Free Software Foundation; either version 3 of the License, or
	* (at your option) any later version.
	*
	* GnuPG is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with this program; if not, see <http://www.gnu.org/licenses/>.
	*/

	#include <config.h>
	#include <errno.h>
	#include <stdio.h>
	#include <stdlib.h>
	#include <string.h>
	#include <ctype.h>
	#include <unistd.h>
	#ifdef HAVE_DOSISH_SYSTEM
	#include <fcntl.h> /* for setmode() */
	#endif
	#ifdef HAVE_LIBREADLINE
	#define GNUPG_LIBREADLINE_H_INCLUDED
	#include <readline/readline.h>
	#endif

	#define INCLUDED_BY_MAIN_MODULE 1
	#include "gpg.h"
	#include "util.h"
	#include "packet.h"
	#include "iobuf.h"
	#include "main.h"
	#include "options.h"
	#include "keydb.h"
	#include "trustdb.h"
	#include "filter.h"
	#include "ttyio.h"
	#include "i18n.h"
	#include "sysutils.h"
	#include "status.h"
	#include "call-agent.h"
	#include "../common/init.h"


	enum cmd_and_opt_values {
	aNull = 0,
	oQuiet = 'q',
	oVerbose = 'v',
	oBatch = 500,
	oKeyring,
	oIgnoreTimeConflict,
	oStatusFD,
	oLoggerFD,
	oHomedir,
	aTest
	};


	static ARGPARSE_OPTS opts[] = {
	ARGPARSE_group (300, N_("@\nOptions:\n ")),

	ARGPARSE_s_n (oVerbose, "verbose", N_("verbose")),
	ARGPARSE_s_n (oQuiet, "quiet", N_("be somewhat more quiet")),
	ARGPARSE_s_s (oKeyring, "keyring",
	N_("\|FILE\|take the keys from the keyring FILE")),
	ARGPARSE_s_n (oIgnoreTimeConflict, "ignore-time-conflict",
	N_("make timestamp conflicts only a warning")),
	ARGPARSE_s_i (oStatusFD, "status-fd",
	N_("\|FD\|write status info to this FD")),
	ARGPARSE_s_i (oLoggerFD, "logger-fd", "@"),
	ARGPARSE_s_s (oHomedir, "homedir", "@"),

	ARGPARSE_end ()
	};



	int g10_errors_seen = 0;


	static char *
	make_libversion (const char libname, const char (getfnc)(const char))
	{
	const char *s;
	char *result;

	s = getfnc (NULL);
	result = xmalloc (strlen (libname) + 1 + strlen (s) + 1);
	strcpy (stpcpy (stpcpy (result, libname), " "), s);
	return result;
	}

	static const char *
	my_strusage( int level )
	{
	static char *ver_gcry;
	const char *p;

	switch (level)
	{
	case 11: p = "@GPG@v (GnuPG)";
	break;
	case 13: p = VERSION; break;
	case 17: p = PRINTABLE_OS_NAME; break;
	case 19: p = _("Please report bugs to <@EMAIL@>.\n"); break;

	case 1:
	case 40: p = _("Usage: gpgv [options] [files] (-h for help)");
	break;
	case 41: p = _("Syntax: gpgv [options] [files]\n"
	"Check signatures against known trusted keys\n");
	break;

	case 20:
	if (!ver_gcry)
	ver_gcry = make_libversion ("libgcrypt", gcry_check_version);
	p = ver_gcry;
	break;


	default: p = NULL;
	}
	return p;
	}



	int
	main( int argc, char **argv )
	{
	ARGPARSE_ARGS pargs;
	int rc=0;
	strlist_t sl;
	strlist_t nrings = NULL;
	unsigned configlineno;
	ctrl_t ctrl;

	early_system_init ();
	set_strusage (my_strusage);
	log_set_prefix ("gpgv", 1);

	/* Make sure that our subsystems are ready. */
	i18n_init();
	init_common_subsystems (&argc, &argv);

	if (!gcry_check_version (NEED_LIBGCRYPT_VERSION) )
	{
	log_fatal ( _("%s is too old (need %s, have %s)\n"), "libgcrypt",
	NEED_LIBGCRYPT_VERSION, gcry_check_version (NULL) );
	}
	gcry_control (GCRYCTL_DISABLE_SECMEM, 0);

	gnupg_init_signals (0, NULL);

	opt.command_fd = -1; /* no command fd */
	opt.keyserver_options.options \|= KEYSERVER_AUTO_KEY_RETRIEVE;
	opt.trust_model = TM_ALWAYS;
	opt.batch = 1;

	opt.homedir = default_homedir ();

	tty_no_terminal(1);
	tty_batchmode(1);
	dotlock_disable ();
	gcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0);

	pargs.argc = &argc;
	pargs.argv = &argv;
	pargs.flags= 1; /* do not remove the args */
	while (optfile_parse( NULL, NULL, &configlineno, &pargs, opts))
	{
	switch (pargs.r_opt)
	{
	case oQuiet: opt.quiet = 1; break;
	case oVerbose:
	opt.verbose++;
	opt.list_sigs=1;
	gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
	break;
	case oKeyring: append_to_strlist( &nrings, pargs.r.ret_str); break;
	case oStatusFD: set_status_fd( pargs.r.ret_int ); break;
	case oLoggerFD:
	log_set_fd (translate_sys2libc_fd_int (pargs.r.ret_int, 1));
	break;
	case oHomedir: opt.homedir = pargs.r.ret_str; break;
	case oIgnoreTimeConflict: opt.ignore_time_conflict = 1; break;
	default : pargs.err = ARGPARSE_PRINT_ERROR; break;
	}
	}

	if (log_get_errorcount (0))
	g10_exit(2);

	if (opt.verbose > 1)
	set_packet_list_mode(1);

	/* Note: We open all keyrings in read-only mode. */
	if (!nrings) /* No keyring given: use default one. */
	- keydb_add_resource ("trustedkeys" EXTSEP_S GPGEXT_GPG,
	- KEYDB_RESOURCE_FLAG_READONLY);
	+ keydb_add_resource ("trustedkeys" EXTSEP_S "kbx",
	+ (KEYDB_RESOURCE_FLAG_READONLY
	+ \|KEYDB_RESOURCE_FLAG_GPGVDEF));
	for (sl = nrings; sl; sl = sl->next)
	keydb_add_resource (sl->d, KEYDB_RESOURCE_FLAG_READONLY);

	FREE_STRLIST (nrings);

	ctrl = xcalloc (1, sizeof *ctrl);

	if ((rc = verify_signatures (ctrl, argc, argv)))
	log_error("verify signatures failed: %s\n", gpg_strerror (rc) );

	xfree (ctrl);

	/* cleanup */
	g10_exit (0);
	return 8; /NOTREACHED/
	}


	void
	g10_exit( int rc )
	{
	rc = rc? rc : log_get_errorcount(0)? 2 : g10_errors_seen? 1 : 0;
	exit(rc );
	}


	/* Stub:
	* We have to override the trustcheck from pkclist.c becuase
	* this utility assumes that all keys in the keyring are trustworthy
	*/
	int
	check_signatures_trust( PKT_signature *sig )
	{
	(void)sig;
	return 0;
	}

	void
	read_trust_options(byte trust_model, ulong created, ulong *nextcheck,
	byte marginals, byte completes, byte *cert_depth,
	byte *min_cert_level)
	{
	(void)trust_model;
	(void)created;
	(void)nextcheck;
	(void)marginals;
	(void)completes;
	(void)cert_depth;
	(void)min_cert_level;
	}

	/* Stub:
	* We don't have the trustdb , so we have to provide some stub functions
	* instead
	*/

	int
	cache_disabled_value(PKT_public_key *pk)
	{
	(void)pk;
	return 0;
	}

	void
	check_trustdb_stale(void)
	{
	}

	int
	get_validity_info (PKT_public_key pk, PKT_user_id uid)
	{
	(void)pk;
	(void)uid;
	return '?';
	}

	unsigned int
	get_validity (PKT_public_key pk, PKT_user_id uid)
	{
	(void)pk;
	(void)uid;
	return 0;
	}

	const char *
	trust_value_to_string (unsigned int value)
	{
	(void)value;
	return "err";
	}

	const char *
	uid_trust_string_fixed (PKT_public_key key, PKT_user_id uid)
	{
	(void)key;
	(void)uid;
	return "err";
	}

	int
	get_ownertrust_info (PKT_public_key *pk)
	{
	(void)pk;
	return '?';
	}

	unsigned int
	get_ownertrust (PKT_public_key *pk)
	{
	(void)pk;
	return TRUST_UNKNOWN;
	}


	/* Stubs:
	* Because we only work with trusted keys, it does not make sense to
	* get them from a keyserver
	*/

	struct keyserver_spec *
	keyserver_match (struct keyserver_spec *spec)
	{
	(void)spec;
	return NULL;
	}

	int
	keyserver_import_keyid (u32 keyid, void dummy)
	{
	(void)keyid;
	(void)dummy;
	return -1;
	}

	int
	keyserver_import_cert (const char *name)
	{
	(void)name;
	return -1;
	}

	int
	keyserver_import_pka (const char name,unsigned char fpr)
	{
	(void)name;
	(void)fpr;
	return -1;
	}

	int
	keyserver_import_name (const char name,struct keyserver_spec spec)
	{
	(void)name;
	(void)spec;
	return -1;
	}

	int
	keyserver_import_ldap (const char *name)
	{
	(void)name;
	return -1;
	}

	/* Stub:
	* No encryption here but mainproc links to these functions.
	*/
	gpg_error_t
	get_session_key (PKT_pubkey_enc k, DEK dek)
	{
	(void)k;
	(void)dek;
	return GPG_ERR_GENERAL;
	}

	/* Stub: */
	gpg_error_t
	get_override_session_key (DEK dek, const char string)
	{
	(void)dek;
	(void)string;
	return GPG_ERR_GENERAL;
	}

	/* Stub: */
	int
	decrypt_data (ctrl_t ctrl, void procctx, PKT_encrypted ed, DEK *dek)
	{
	(void)ctrl;
	(void)procctx;
	(void)ed;
	(void)dek;
	return GPG_ERR_GENERAL;
	}


	/* Stub:
	* No interactive commands, so we don't need the helptexts
	*/
	void
	display_online_help (const char *keyword)
	{
	(void)keyword;
	}

	/* Stub:
	* We don't use secret keys, but getkey.c links to this
	*/
	int
	check_secret_key (PKT_public_key *pk, int n)
	{
	(void)pk;
	(void)n;
	return GPG_ERR_GENERAL;
	}

	/* Stub:
	* No secret key, so no passphrase needed
	*/
	DEK *
	passphrase_to_dek (u32 *keyid, int pubkey_algo,
	int cipher_algo, STRING2KEY *s2k, int mode,
	const char tmp, int canceled)
	{
	(void)keyid;
	(void)pubkey_algo;
	(void)cipher_algo;
	(void)s2k;
	(void)mode;
	(void)tmp;

	if (canceled)
	*canceled = 0;
	return NULL;
	}

	void
	passphrase_clear_cache (u32 keyid, const char cacheid, int algo)
	{
	(void)keyid;
	(void)cacheid;
	(void)algo;
	}

	struct keyserver_spec *
	parse_preferred_keyserver(PKT_signature *sig)
	{
	(void)sig;
	return NULL;
	}

	struct keyserver_spec *
	parse_keyserver_uri (const char *uri, int require_scheme,
	const char *configname, unsigned int configlineno)
	{
	(void)uri;
	(void)require_scheme;
	(void)configname;
	(void)configlineno;
	return NULL;
	}

	void
	free_keyserver_spec (struct keyserver_spec *keyserver)
	{
	(void)keyserver;
	}

	/* Stubs to avoid linking to photoid.c */
	void
	show_photos (const struct user_attribute attrs, int count, PKT_public_key pk)
	{
	(void)attrs;
	(void)count;
	(void)pk;
	}

	int
	parse_image_header (const struct user_attribute attr, byte type, u32 *len)
	{
	(void)attr;
	(void)type;
	(void)len;
	return 0;
	}

	char *
	image_type_to_string (byte type, int string)
	{
	(void)type;
	(void)string;
	return NULL;
	}

	#ifdef ENABLE_CARD_SUPPORT
	int
	agent_scd_getattr (const char name, struct agent_card_info_s info)
	{
	(void)name;
	(void)info;
	return 0;
	}
	#endif /* ENABLE_CARD_SUPPORT */

	/* We do not do any locking, so use these stubs here */
	void
	dotlock_disable (void)
	{
	}

	dotlock_t
	dotlock_create (const char *file_to_lock, unsigned int flags)
	{
	(void)file_to_lock;
	(void)flags;
	return NULL;
	}

	void
	dotlock_destroy (dotlock_t h)
	{
	(void)h;
	}

	int
	dotlock_take (dotlock_t h, long timeout)
	{
	(void)h;
	(void)timeout;
	return 0;
	}

	int
	dotlock_release (dotlock_t h)
	{
	(void)h;
	return 0;
	}

	void
	dotlock_remove_lockfiles (void)
	{
	}

	gpg_error_t
	agent_probe_secret_key (ctrl_t ctrl, PKT_public_key *pk)
	{
	(void)ctrl;
	(void)pk;
	return gpg_error (GPG_ERR_NO_SECKEY);
	}

	gpg_error_t
	agent_probe_any_secret_key (ctrl_t ctrl, kbnode_t keyblock)
	{
	(void)ctrl;
	(void)keyblock;
	return gpg_error (GPG_ERR_NO_SECKEY);
	}

	gpg_error_t
	agent_get_keyinfo (ctrl_t ctrl, const char hexkeygrip, char *r_serialno)
	{
	(void)ctrl;
	(void)hexkeygrip;
	*r_serialno = NULL;
	return gpg_error (GPG_ERR_NO_SECKEY);
	}

	gpg_error_t
	gpg_dirmngr_get_pka (ctrl_t ctrl, const char *userid,
	unsigned char *r_fpr, size_t r_fprlen,
	char **r_url)
	{
	(void)ctrl;
	(void)userid;
	if (r_fpr)
	*r_fpr = NULL;
	if (r_fprlen)
	*r_fprlen = 0;
	if (r_url)
	*r_url = NULL;
	return gpg_error (GPG_ERR_NOT_FOUND);
	}
	diff --git a/g10/keydb.c b/g10/keydb.c
	index 3dc9ec72e..b31c6a62c 100644
	--- a/g10/keydb.c
	+++ b/g10/keydb.c
	@@ -1,1769 +1,1787 @@
	/* keydb.c - key database dispatcher
	* Copyright (C) 2001-2013 Free Software Foundation, Inc.
	* Coyrright (C) 2001-2015 Werner Koch
	*
	* This file is part of GnuPG.
	*
	* GnuPG is free software; you can redistribute it and/or modify
	* it under the terms of the GNU General Public License as published by
	* the Free Software Foundation; either version 3 of the License, or
	* (at your option) any later version.
	*
	* GnuPG is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with this program; if not, see <http://www.gnu.org/licenses/>.
	*/

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

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

	static int active_handles;

	typedef enum
	{
	KEYDB_RESOURCE_TYPE_NONE = 0,
	KEYDB_RESOURCE_TYPE_KEYRING,
	KEYDB_RESOURCE_TYPE_KEYBOX
	} KeydbResourceType;
	#define MAX_KEYDB_RESOURCES 40

	struct resource_item
	{
	KeydbResourceType type;
	union {
	KEYRING_HANDLE kr;
	KEYBOX_HANDLE kb;
	} u;
	void *token;
	};

	static struct resource_item all_resources[MAX_KEYDB_RESOURCES];
	static int used_resources;
	static void *primary_keyring=NULL;

	struct keydb_handle
	{
	int locked;
	int found;
	int saved_found;
	unsigned long skipped_long_blobs;
	int no_caching;
	int current;
	int used; /* Number of items in ACTIVE. */
	struct resource_item active[MAX_KEYDB_RESOURCES];
	};


	/* This object is used to keep a list of keyids in a linked list. */
	typedef struct kid_list_s
	{
	struct kid_list_s *next;
	u32 kid[2];
	int state; /* True if found. */
	} *kid_list_t;

	/* To avoid looking up a key by keyid where we know that it does not
	yet exist, we keep a table of keyids with search results. This
	improves the --list-sigs and --check-sigs commands substantively.
	To avoid extra complexity we clear the entire table on any insert
	or update operation. The array is indexed by the LSB of the keyid.
	KID_FOUND_TABLE_COUNT gives the number of keys in the table. */
	static kid_list_t kid_found_table[256];
	static unsigned int kid_found_table_count;


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

	struct {
	enum keyblock_cache_states state;
	byte fpr[MAX_FINGERPRINT_LEN];
	iobuf_t iobuf; /* Image of the keyblock. */
	u32 *sigstatus;
	int pk_no;
	int uid_no;
	} keyblock_cache;


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


	/* Checkwhether the keyid KID is in the table of found or not found
	keyids.

	Returns:
	0 - Keyid not in table
	1 - Keyid in table because not found in a previous search
	2 - Keyid in table because found in a previous search
	*/
	static int
	kid_not_found_p (u32 *kid)
	{
	kid_list_t k;

	for (k = kid_found_table[kid[0] % 256]; 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) => %s\n",
	(ulong)kid[0], (ulong)kid[1],
	k->state? "false (found)": "true");
	return k->state? 2 : 1;
	}

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


	/* Put the keyid KID into the table of keyids with their find states of
	previous searches. Note that there is no check whether the keyid
	is already in the table, thus kid_not_found_p() should be used prior. */
	static void
	kid_not_found_insert (u32 *kid, int found)
	{
	kid_list_t k;

	if (DBG_CACHE)
	log_debug ("keydb: kid_not_found_insert (%08lx%08lx, %d)\n",
	(ulong)kid[0], (ulong)kid[1], found);
	k = xmalloc (sizeof *k);
	k->kid[0] = kid[0];
	k->kid[1] = kid[1];
	k->state = found;
	k->next = kid_found_table[kid[0]%256];
	kid_found_table[kid[0]%256] = k;
	kid_found_table_count++;
	}


	/* Flush the entire table of keyids whche were not found in previous
	searches. */
	static void
	kid_not_found_flush (void)
	{
	kid_list_t k, knext;
	int i;

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

	if (!kid_found_table_count)
	return;

	for (i=0; i < DIM(kid_found_table); i++)
	{
	for (k = kid_found_table[i]; k; k = knext)
	{
	knext = k->next;
	xfree (k);
	}
	kid_found_table[i] = NULL;
	}
	kid_found_table_count = 0;
	}


	static void
	keyblock_cache_clear (void)
	{
	keyblock_cache.state = KEYBLOCK_CACHE_EMPTY;
	xfree (keyblock_cache.sigstatus);
	keyblock_cache.sigstatus = NULL;
	iobuf_close (keyblock_cache.iobuf);
	keyblock_cache.iobuf = NULL;
	}


	/* 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 IS_BOX is true
	the filename is expected to be a keybox. If FORCE_CREATE is true
	the keyring or keybox shall be created. */
	static int
	maybe_create_keyring_or_box (char *filename, int is_box, int force_create)
	{
	dotlock_t lockhd = NULL;
	IOBUF iobuf;
	int rc;
	mode_t oldmask;
	char *last_slash_in_filename;
	int save_slash;

	/* A quick test whether the filename already exists. */
	if (!access (filename, F_OK))
	return 0;

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

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

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

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

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

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

	/* Now the real test while we are locked. */
	if (!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);
	if (is_secured_filename (filename))
	{
	iobuf = NULL;
	gpg_err_set_errno (EPERM);
	}
	else
	iobuf = iobuf_create (filename, 0);
	umask (oldmask);
	if (!iobuf)
	{
	rc = gpg_error_from_syserror ();
	if (is_box)
	log_error (_("error creating keybox '%s': %s\n"),
	filename, gpg_strerror (rc));
	else
	log_error (_("error creating keyring '%s': %s\n"),
	filename, gpg_strerror (rc));
	goto leave;
	}

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

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

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

	rc = 0;

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


	/* Helper for keydb_add_resource. Opens FILENAME to figures out the
	resource type. Returns the resource type and a flag at R_NOTFOUND
	indicating whether FILENAME could be opened at all. If the openpgp
	flag is set in a keybox header, R_OPENPGP will be set to true. */
	static KeydbResourceType
	rt_from_file (const char filename, int r_found, int *r_openpgp)
	{
	u32 magic;
	unsigned char verbuf[4];
	FILE *fp;
	KeydbResourceType rt = KEYDB_RESOURCE_TYPE_NONE;

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

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

	fclose (fp);
	}

	return rt;
	}


	/*
	* Register a resource (keyring or aeybox). The first keyring or
	* keybox which is added by this function is created if it does not
	* exist. FLAGS are a combination of the KEYDB_RESOURCE_FLAG_
	* constants as defined in keydb.h.
	*/
	gpg_error_t
	keydb_add_resource (const char *url, unsigned int flags)
	{
	static int any_registered;
	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);
	int rc = 0;
	KeydbResourceType rt = KEYDB_RESOURCE_TYPE_NONE;
	void *token;

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

	/* Do we have an URL?
	* gnupg-ring:filename := this is a plain keyring.
	* gnupg-kbx:filename := this is a keybox file.
	* filename := See what is is, but create as plain keyring.
	*/
	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 );
	rc = 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 (opt.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 );
	rc = gpg_error (GPG_ERR_GENERAL);
	goto leave;

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

	if (keyring_register_filename (filename, read_only, &token))
	{
	if (used_resources >= MAX_KEYDB_RESOURCES)
	rc = gpg_error (GPG_ERR_RESOURCE_LIMIT);
	else
	{
	if ((flags & KEYDB_RESOURCE_FLAG_PRIMARY))
	primary_keyring = 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_keyring = token;
	}
	break;

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

	/* FIXME: How do we register a read-only keybox? */
	token = keybox_register_file (filename, 0);
	if (token)
	{
	if (used_resources >= MAX_KEYDB_RESOURCES)
	rc = gpg_error (GPG_ERR_RESOURCE_LIMIT);
	else
	{
	/* if ((flags & KEYDB_RESOURCE_FLAG_PRIMARY)) */
	/* primary_keyring = token; */
	all_resources[used_resources].type = rt;
	all_resources[used_resources].u.kb = NULL; /* Not used here */
	all_resources[used_resources].token = token;

	/* FIXME: Do a compress run if needed and no other
	user is currently using the keybox. */

	used_resources++;
	}
	}
	else
	{
	/* Already registered. We will mark it as the primary key
	if requested. */
	/* FIXME: How to do that? Change the keybox interface? */
	/* if ((flags & KEYDB_RESOURCE_FLAG_PRIMARY)) */
	/* primary_keyring = token; */
	}
	}
	break;

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

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

	leave:
	if (rc)
	log_error (_("keyblock resource '%s': %s\n"), filename, gpg_strerror (rc));
	else
	any_registered = 1;
	xfree (filename);
	return rc;
	}


	void
	keydb_dump_stats (void)
	{
	if (kid_found_table_count)
	log_info ("keydb: kid_not_found_table: total: %u\n", kid_found_table_count);
	}


	KEYDB_HANDLE
	keydb_new (void)
	{
	KEYDB_HANDLE hd;
	int i, j;

	if (DBG_CLOCK)
	log_clock ("keydb_new");

	hd = xmalloc_clear (sizeof *hd);
	hd->found = -1;
	hd->saved_found = -1;

	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_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) {
	xfree (hd);
	return NULL; /* fixme: release all previously allocated handles*/
	}
	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)
	{
	xfree (hd);
	return NULL; /* fixme: release all previously allocated handles*/
	}
	j++;
	break;
	}
	}
	hd->used = j;

	active_handles++;
	return hd;
	}


	void
	keydb_release (KEYDB_HANDLE hd)
	{
	int i;

	if (!hd)
	return;
	assert (active_handles > 0);
	active_handles--;

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

	xfree (hd);
	}


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


	/*
	* 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->found >= 0 && hd->found < hd->used)
	idx = hd->found;
	else if ( hd->current >= 0 && hd->current < hd->used)
	idx = hd->current;
	else
	idx = 0;

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

	return s? s: "";
	}



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

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

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

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

	return rc;
	}


	static void
	unlock_all (KEYDB_HANDLE hd)
	{
	int i;

	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);
	break;
	}
	}
	hd->locked = 0;
	}



	/* Push the last found state if any. */
	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;
	}


	/* Pop the last found state. */
	void
	keydb_pop_found_state (KEYDB_HANDLE hd)
	{
	if (!hd)
	return;

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

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



	static gpg_error_t
	parse_keyblock_image (iobuf_t iobuf, int pk_no, int uid_no,
	const u32 sigstatus, kbnode_t r_keyblock)
	{
	gpg_error_t err;
	PACKET *pkt;
	kbnode_t keyblock = NULL;
	kbnode_t node, *tail;
	int in_cert, save_mode;
	u32 n_sigs;
	int pk_count, uid_count;

	*r_keyblock = NULL;

	pkt = xtrymalloc (sizeof *pkt);
	if (!pkt)
	return gpg_error_from_syserror ();
	init_packet (pkt);
	save_mode = set_packet_list_mode (0);
	in_cert = 0;
	n_sigs = 0;
	tail = NULL;
	pk_count = uid_count = 0;
	while ((err = parse_packet (iobuf, pkt)) != -1)
	{
	if (gpg_err_code (err) == GPG_ERR_UNKNOWN_PACKET)
	{
	free_packet (pkt);
	init_packet (pkt);
	continue;
	}
	if (err)
	{
	log_error ("parse_keyblock_image: read error: %s\n",
	gpg_strerror (err));
	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:
	break; /* Allowed per RFC. */

	default:
	/* Note that can't allow ring trust packets here and some of
	the other GPG specific packets don't make sense either. */
	log_error ("skipped packet of type %d in keybox\n",
	(int)pkt->pkttype);
	free_packet(pkt);
	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;

	if (pkt->pkttype == PKT_SIGNATURE && sigstatus)
	{
	PKT_signature *sig = pkt->pkt.signature;

	n_sigs++;
	if (n_sigs > sigstatus[0])
	{
	log_error ("parse_keyblock_image: "
	"more signatures than found in the meta data\n");
	err = gpg_error (GPG_ERR_INV_KEYRING);
	break;

	}
	if (sigstatus[n_sigs])
	{
	sig->flags.checked = 1;
	if (sigstatus[n_sigs] == 1 )
	; /* missing key */
	else if (sigstatus[n_sigs] == 2 )
	; /* bad signature */
	else if (sigstatus[n_sigs] < 0x10000000)
	; /* bad flag */
	else
	{
	sig->flags.valid = 1;
	/* Fixme: Shall we set the expired flag here? */
	}
	}
	}

	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 && sigstatus && n_sigs != sigstatus[0])
	{
	log_error ("parse_keyblock_image: signature count does not match\n");
	err = gpg_error (GPG_ERR_INV_KEYRING);
	}

	if (err)
	release_kbnode (keyblock);
	else
	*r_keyblock = keyblock;
	free_packet (pkt);
	xfree (pkt);
	return err;
	}


	/*
	* Return the last found keyring. Caller must free it.
	* The returned keyblock has the kbode flag bit 0 set for the node with
	* the public key used to locate the keyblock or flag bit 1 set for
	* the user ID node.
	*/
	gpg_error_t
	keydb_get_keyblock (KEYDB_HANDLE hd, KBNODE *ret_kb)
	{
	gpg_error_t err = 0;

	*ret_kb = NULL;

	if (!hd)
	return gpg_error (GPG_ERR_INV_ARG);

	if (DBG_CLOCK)
	log_clock ("keydb_get_keybock enter");

	if (keyblock_cache.state == KEYBLOCK_CACHE_FILLED)
	{
	iobuf_seek (keyblock_cache.iobuf, 0);
	err = parse_keyblock_image (keyblock_cache.iobuf,
	keyblock_cache.pk_no,
	keyblock_cache.uid_no,
	keyblock_cache.sigstatus,
	ret_kb);
	if (err)
	keyblock_cache_clear ();
	if (DBG_CLOCK)
	log_clock (err? "keydb_get_keyblock leave (cached, failed)"
	: "keydb_get_keyblock leave (cached)");
	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;
	u32 *sigstatus;
	int pk_no, uid_no;

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

	if (keyblock_cache.state != KEYBLOCK_CACHE_FILLED)
	keyblock_cache_clear ();

	if (DBG_CLOCK)
	log_clock (err? "keydb_get_keyblock leave (failed)"
	: "keydb_get_keyblock leave");
	return err;
	}


	/* Build a keyblock image from KEYBLOCK. Returns 0 on success and
	only then stores a new iobuf object at R_IOBUF and a signature
	status vecotor at R_SIGSTATUS. */
	static gpg_error_t
	build_keyblock_image (kbnode_t keyblock, iobuf_t r_iobuf, u32 *r_sigstatus)
	{
	gpg_error_t err;
	iobuf_t iobuf;
	kbnode_t kbctx, node;
	u32 n_sigs;
	u32 *sigstatus;

	*r_iobuf = NULL;
	if (r_sigstatus)
	*r_sigstatus = NULL;

	/* Allocate a vector for the signature cache. This is an array of
	u32 values with the first value giving the number of elements to
	follow and each element descriping the cache status of the
	signature. */
	if (r_sigstatus)
	{
	for (kbctx=NULL, n_sigs=0; (node = walk_kbnode (keyblock, &kbctx, 0));)
	if (node->pkt->pkttype == PKT_SIGNATURE)
	n_sigs++;
	sigstatus = xtrycalloc (1+n_sigs, sizeof *sigstatus);
	if (!sigstatus)
	return gpg_error_from_syserror ();
	}
	else
	sigstatus = NULL;

	iobuf = iobuf_temp ();
	for (kbctx = NULL, n_sigs = 0; (node = walk_kbnode (keyblock, &kbctx, 0));)
	{
	/* Make sure to use only packets valid on a keyblock. */
	switch (node->pkt->pkttype)
	{
	case PKT_PUBLIC_KEY:
	case PKT_PUBLIC_SUBKEY:
	case PKT_SIGNATURE:
	case PKT_USER_ID:
	case PKT_ATTRIBUTE:
	/* Note that we don't want the ring trust packets. They are
	not useful. */
	break;
	default:
	continue;
	}

	err = build_packet (iobuf, node->pkt);
	if (err)
	{
	iobuf_close (iobuf);
	return err;
	}

	/* Build signature status vector. */
	if (node->pkt->pkttype == PKT_SIGNATURE)
	{
	PKT_signature *sig = node->pkt->pkt.signature;

	n_sigs++;
	/* Fixme: Detect the "missing key" status. */
	if (sig->flags.checked && sigstatus)
	{
	if (sig->flags.valid)
	{
	if (!sig->expiredate)
	sigstatus[n_sigs] = 0xffffffff;
	else if (sig->expiredate < 0x1000000)
	sigstatus[n_sigs] = 0x10000000;
	else
	sigstatus[n_sigs] = sig->expiredate;
	}
	else
	sigstatus[n_sigs] = 0x00000002; /* Bad signature. */
	}
	}
	}
	if (sigstatus)
	sigstatus[0] = n_sigs;

	*r_iobuf = iobuf;
	if (r_sigstatus)
	*r_sigstatus = sigstatus;
	return 0;
	}


	/*
	* Update the current keyblock with the keyblock KB
	*/
	gpg_error_t
	keydb_update_keyblock (KEYDB_HANDLE hd, kbnode_t kb)
	{
	gpg_error_t err;

	if (!hd)
	return gpg_error (GPG_ERR_INV_ARG);

	kid_not_found_flush ();
	keyblock_cache_clear ();

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

	if (opt.dry_run)
	return 0;

	err = lock_all (hd);
	if (err)
	return err;

	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, NULL);
	if (!err)
	{
	err = keybox_update_keyblock (hd->active[hd->found].u.kb,
	iobuf_get_temp_buffer (iobuf),
	iobuf_get_temp_length (iobuf));
	iobuf_close (iobuf);
	}
	}
	break;
	}

	unlock_all (hd);
	return err;
	}


	/*
	* Insert a new KB into one of the resources.
	*/
	gpg_error_t
	keydb_insert_keyblock (KEYDB_HANDLE hd, kbnode_t kb)
	{
	gpg_error_t err;
	int idx;

	if (!hd)
	return gpg_error (GPG_ERR_INV_ARG);

	kid_not_found_flush ();
	keyblock_cache_clear ();

	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;
	u32 *sigstatus;

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

	unlock_all (hd);
	return err;
	}


	/*
	* Delete the current keyblock.
	*/
	gpg_error_t
	keydb_delete_keyblock (KEYDB_HANDLE hd)
	{
	gpg_error_t rc;

	if (!hd)
	return gpg_error (GPG_ERR_INV_ARG);

	kid_not_found_flush ();
	keyblock_cache_clear ();

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

	if (opt.dry_run)
	return 0;

	rc = lock_all (hd);
	if (rc)
	return rc;

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

	unlock_all (hd);
	return rc;
	}



	/*
	* Locate the default writable key resource, so that the next
	* operation (which is only relevant for inserts) will be done on this
	* resource.
	*/
	gpg_error_t
	keydb_locate_writable (KEYDB_HANDLE hd, const char *reserved)
	{
	gpg_error_t rc;

	(void)reserved;

	if (!hd)
	return GPG_ERR_INV_ARG;

	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_keyring)
	{
	for ( ; hd->current >= 0 && hd->current < hd->used; hd->current++)
	{
	if(hd->active[hd->current].token==primary_keyring)
	{
	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 caches of all key resources.
	*/
	void
	keydb_rebuild_caches (int noisy)
	{
	int i, rc;

	keyblock_cache_clear ();

	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 (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 since the last search reset. */
	unsigned long
	keydb_get_skipped_counter (KEYDB_HANDLE hd)
	{
	return hd ? hd->skipped_long_blobs : 0;
	}


	/*
	* Start the next search on this handle right at the beginning
	*/
	gpg_error_t
	keydb_search_reset (KEYDB_HANDLE hd)
	{
	gpg_error_t rc = 0;
	int i;

	if (!hd)
	return gpg_error (GPG_ERR_INV_ARG);

	keyblock_cache_clear ();

	if (DBG_CLOCK)
	log_clock ("keydb_search_reset");

	if (DBG_CACHE)
	log_debug ("keydb_search: reset (hd=%p)", 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;
	}
	}
	return rc;
	}


	static void
	dump_search_desc (KEYDB_HANDLE hd, const char *text,
	KEYDB_SEARCH_DESC *desc, size_t ndesc)
	{
	int n;
	const char *s;

	for (n=0; n < ndesc; n++)
	{
	switch (desc[n].mode)
	{
	case KEYDB_SEARCH_MODE_NONE: s = "none"; break;
	case KEYDB_SEARCH_MODE_EXACT: s = "exact"; break;
	case KEYDB_SEARCH_MODE_SUBSTR: s = "substr"; break;
	case KEYDB_SEARCH_MODE_MAIL: s = "mail"; break;
	case KEYDB_SEARCH_MODE_MAILSUB: s = "mailsub"; break;
	case KEYDB_SEARCH_MODE_MAILEND: s = "mailend"; break;
	case KEYDB_SEARCH_MODE_WORDS: s = "words"; break;
	case KEYDB_SEARCH_MODE_SHORT_KID: s = "short_kid"; break;
	case KEYDB_SEARCH_MODE_LONG_KID: s = "long_kid"; break;
	case KEYDB_SEARCH_MODE_FPR16: s = "fpr16"; break;
	case KEYDB_SEARCH_MODE_FPR20: s = "fpr20"; break;
	case KEYDB_SEARCH_MODE_FPR: s = "fpr"; break;
	case KEYDB_SEARCH_MODE_ISSUER: s = "issuer"; break;
	case KEYDB_SEARCH_MODE_ISSUER_SN: s = "issuer_sn"; break;
	case KEYDB_SEARCH_MODE_SN: s = "sn"; break;
	case KEYDB_SEARCH_MODE_SUBJECT: s = "subject"; break;
	case KEYDB_SEARCH_MODE_KEYGRIP: s = "keygrip"; break;
	case KEYDB_SEARCH_MODE_FIRST: s = "first"; break;
	case KEYDB_SEARCH_MODE_NEXT: s = "next"; break;
	default: s = "?"; break;
	}
	if (!n)
	log_debug ("%s: mode=%s (hd=%p)", text, s, hd);
	else
	log_debug ("%*s mode=%s", (int)strlen (text), "", s);
	if (desc[n].mode == KEYDB_SEARCH_MODE_LONG_KID)
	log_printf (" %08lX%08lX", (unsigned long)desc[n].u.kid[0],
	(unsigned long)desc[n].u.kid[1]);
	else if (desc[n].mode == KEYDB_SEARCH_MODE_SHORT_KID)
	log_printf (" %08lX", (unsigned long)desc[n].u.kid[1]);
	else if (desc[n].mode == KEYDB_SEARCH_MODE_SUBSTR)
	log_printf (" '%s'", desc[n].u.name);
	}
	}


	/*
	* Search through all keydb resources, starting at the current
	* position, for a keyblock which contains one of the keys described
	* in the DESC array. Returns GPG_ERR_NOT_FOUND if no matching
	* keyring was found.
	*/
	gpg_error_t
	keydb_search (KEYDB_HANDLE hd, KEYDB_SEARCH_DESC *desc,
	size_t ndesc, size_t *descindex)
	{
	gpg_error_t rc;
	int once_found = 0;

	if (descindex)
	descindex = 0; / Make sure it is always set on return. */

	if (!hd)
	return gpg_error (GPG_ERR_INV_ARG);

	if (DBG_CLOCK)
	log_clock ("keydb_search enter");

	if (DBG_CACHE)
	dump_search_desc (hd, "keydb_search", desc, ndesc);


	/* Note that we track the found state in the table to cope with the
	case that a initial search found the key and the next search
	(without a reset) did not found the key. Without keeping the
	found state we would falsely claim that the key has not been
	found. Actually this is quite common because we need to check
	for ambgious keyids. */
	if (ndesc == 1 && desc[0].mode == KEYDB_SEARCH_MODE_LONG_KID
	&& (once_found = kid_not_found_p (desc[0].u.kid)) == 1 )
	{
	if (DBG_CLOCK)
	log_clock ("keydb_search leave (not found, 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 (!hd->no_caching
	&& ndesc == 1
	&& (desc[0].mode == KEYDB_SEARCH_MODE_FPR20
	\|\| desc[0].mode == KEYDB_SEARCH_MODE_FPR)
	&& keyblock_cache.state == KEYBLOCK_CACHE_FILLED
	&& !memcmp (keyblock_cache.fpr, desc[0].u.fpr, 20))
	{
	/* (DESCINDEX is already set). */
	if (DBG_CLOCK)
	log_clock ("keydb_search leave (cached)");
	return 0;
	}

	rc = -1;
	while ((rc == -1 \|\| gpg_err_code (rc) == 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_KEYRING:
	rc = keyring_search (hd->active[hd->current].u.kr, desc,
	ndesc, descindex);
	break;
	case KEYDB_RESOURCE_TYPE_KEYBOX:
	rc = keybox_search (hd->active[hd->current].u.kb, desc,
	ndesc, KEYBOX_BLOBTYPE_PGP,
	descindex, &hd->skipped_long_blobs);
	break;
	}
	if (rc == -1 \|\| gpg_err_code (rc) == GPG_ERR_EOF)
	{
	/* EOF -> switch to next resource */
	hd->current++;
	}
	else if (!rc)
	hd->found = hd->current;
	}

	rc = ((rc == -1 \|\| gpg_err_code (rc) == GPG_ERR_EOF)
	? gpg_error (GPG_ERR_NOT_FOUND)
	: rc);

	keyblock_cache_clear ();
	if (!hd->no_caching
	&& !rc
	&& ndesc == 1 && (desc[0].mode == KEYDB_SEARCH_MODE_FPR20
	\|\| desc[0].mode == KEYDB_SEARCH_MODE_FPR))
	{
	keyblock_cache.state = KEYBLOCK_CACHE_PREPARED;
	memcpy (keyblock_cache.fpr, desc[0].u.fpr, 20);
	}

	if ((!rc \|\| gpg_err_code (rc) == GPG_ERR_NOT_FOUND)
	&& ndesc == 1 && desc[0].mode == KEYDB_SEARCH_MODE_LONG_KID
	&& !once_found)
	{
	kid_not_found_insert (desc[0].u.kid, !rc);
	}

	if (DBG_CLOCK)
	log_clock (rc? "keydb_search leave (not found)"
	: "keydb_search leave (found)");
	return rc;
	}


	/* Note that in contrast to using keydb_search in search first mode,
	this function skips legacy keys. */
	gpg_error_t
	keydb_search_first (KEYDB_HANDLE hd)
	{
	gpg_error_t err;
	KEYDB_SEARCH_DESC desc;

	memset (&desc, 0, sizeof desc);
	desc.mode = KEYDB_SEARCH_MODE_FIRST;
	err = keydb_search (hd, &desc, 1, NULL);
	if (gpg_err_code (err) == GPG_ERR_LEGACY_KEY)
	err = keydb_search_next (hd);
	return err;
	}


	/* Note that in contrast to using keydb_search in search next mode,
	this fucntion skips legacy keys. */
	gpg_error_t
	keydb_search_next (KEYDB_HANDLE hd)
	{
	gpg_error_t err;
	KEYDB_SEARCH_DESC desc;

	do
	{
	memset (&desc, 0, sizeof desc);
	desc.mode = KEYDB_SEARCH_MODE_NEXT;
	err = keydb_search (hd, &desc, 1, NULL);
	}
	while (gpg_err_code (err) == GPG_ERR_LEGACY_KEY);

	return err;
	}

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

	gpg_error_t
	keydb_search_fpr (KEYDB_HANDLE hd, const byte *fpr)
	{
	gpg_error_t err;
	KEYDB_SEARCH_DESC desc;

	memset (&desc, 0, sizeof desc);
	desc.mode = KEYDB_SEARCH_MODE_FPR;
	memcpy (desc.u.fpr, fpr, MAX_FINGERPRINT_LEN);
	do
	{
	err = keydb_search (hd, &desc, 1, NULL);
	}
	while (gpg_err_code (err) == GPG_ERR_LEGACY_KEY);

	return err;
	}
	diff --git a/g10/keydb.h b/g10/keydb.h
	index 1aa4e0e2f..b64438c5d 100644
	--- a/g10/keydb.h
	+++ b/g10/keydb.h
	@@ -1,321 +1,322 @@
	/* keydb.h - Key database
	* Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
	* 2006, 2010 Free Software Foundation, Inc.
	*
	* This file is part of GnuPG.
	*
	* GnuPG is free software; you can redistribute it and/or modify
	* it under the terms of the GNU General Public License as published by
	* the Free Software Foundation; either version 3 of the License, or
	* (at your option) any later version.
	*
	* GnuPG is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with this program; if not, see <http://www.gnu.org/licenses/>.
	*/

	#ifndef G10_KEYDB_H
	#define G10_KEYDB_H

	#include <assuan.h>

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

	/* What qualifies as a certification (rather than a signature?) */
	#define IS_CERT(s) (IS_KEY_SIG(s) \|\| IS_UID_SIG(s) \|\| IS_SUBKEY_SIG(s) \
	\|\| IS_KEY_REV(s) \|\| IS_UID_REV(s) \|\| IS_SUBKEY_REV(s))
	#define IS_SIG(s) (!IS_CERT(s))
	#define IS_KEY_SIG(s) ((s)->sig_class == 0x1f)
	#define IS_UID_SIG(s) (((s)->sig_class & ~3) == 0x10)
	#define IS_SUBKEY_SIG(s) ((s)->sig_class == 0x18)
	#define IS_KEY_REV(s) ((s)->sig_class == 0x20)
	#define IS_UID_REV(s) ((s)->sig_class == 0x30)
	#define IS_SUBKEY_REV(s) ((s)->sig_class == 0x28)

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

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

	struct kbnode_struct {
	KBNODE next;
	PACKET *pkt;
	int flag;
	int private_flag;
	ulong recno; /* used while updating the trustdb */
	};

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


	enum resource_type {
	rt_UNKNOWN = 0,
	rt_RING = 1
	};


	/****************
	* A data structre to hold information about the external position
	* of a keyblock.
	*/
	struct keyblock_pos_struct {
	int resno; /* resource number */
	enum resource_type rt;
	off_t offset; /* position information */
	unsigned count; /* length of the keyblock in packets */
	iobuf_t fp; /* Used by enum_keyblocks. */
	int secret; /* working on a secret keyring */
	PACKET pkt; / ditto */
	int valid;
	};
	typedef struct keyblock_pos_struct KBPOS;

	/* Structure to hold a couple of public key certificates. */
	typedef struct pk_list PK_LIST; / Deprecated. */
	typedef struct pk_list *pk_list_t;
	struct pk_list
	{
	PK_LIST next;
	PKT_public_key *pk;
	int flags; /* flag bit 1==throw_keyid */
	};

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

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


	typedef struct keydb_handle *KEYDB_HANDLE;


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


	/-- keydb.c --/

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

	gpg_error_t keydb_add_resource (const char *url, unsigned int flags);
	void keydb_dump_stats (void);

	KEYDB_HANDLE keydb_new (void);
	void keydb_release (KEYDB_HANDLE hd);
	void keydb_disable_caching (KEYDB_HANDLE hd);
	void keydb_push_found_state (KEYDB_HANDLE hd);
	void keydb_pop_found_state (KEYDB_HANDLE hd);
	const char *keydb_get_resource_name (KEYDB_HANDLE hd);
	gpg_error_t keydb_get_keyblock (KEYDB_HANDLE hd, KBNODE *ret_kb);
	gpg_error_t keydb_update_keyblock (KEYDB_HANDLE hd, kbnode_t kb);
	gpg_error_t keydb_insert_keyblock (KEYDB_HANDLE hd, kbnode_t kb);
	gpg_error_t keydb_delete_keyblock (KEYDB_HANDLE hd);
	gpg_error_t keydb_locate_writable (KEYDB_HANDLE hd, const char *reserved);
	void keydb_rebuild_caches (int noisy);
	unsigned long keydb_get_skipped_counter (KEYDB_HANDLE hd);
	gpg_error_t keydb_search_reset (KEYDB_HANDLE hd);
	gpg_error_t keydb_search (KEYDB_HANDLE hd, KEYDB_SEARCH_DESC *desc,
	size_t ndesc, size_t *descindex);
	gpg_error_t keydb_search_first (KEYDB_HANDLE hd);
	gpg_error_t keydb_search_next (KEYDB_HANDLE hd);
	gpg_error_t keydb_search_kid (KEYDB_HANDLE hd, u32 *kid);
	gpg_error_t keydb_search_fpr (KEYDB_HANDLE hd, const byte *fpr);


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

	void release_pk_list (PK_LIST pk_list);
	int build_pk_list (ctrl_t ctrl,
	strlist_t rcpts, PK_LIST *ret_pk_list, unsigned use);
	gpg_error_t find_and_check_key (ctrl_t ctrl,
	const char *name, unsigned int use,
	int mark_hidden, pk_list_t *pk_list_addr);

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

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

	/-- passphrase.h --/
	unsigned char encode_s2k_iterations (int iterations);
	assuan_context_t agent_open (int try, const char *orig_codeset);
	void agent_close (assuan_context_t ctx);
	int have_static_passphrase(void);
	const char *get_static_passphrase (void);
	void set_passphrase_from_string(const char *pass);
	void read_passphrase_from_fd( int fd );
	void passphrase_clear_cache ( u32 keyid, const char cacheid, int algo );
	DEK passphrase_to_dek_ext(u32 keyid, int pubkey_algo,
	int cipher_algo, STRING2KEY *s2k, int mode,
	const char *tryagain_text,
	const char custdesc, const char custprompt,
	int *canceled);
	DEK passphrase_to_dek( u32 keyid, int pubkey_algo,
	int cipher_algo, STRING2KEY *s2k, int mode,
	const char tryagain_text, int canceled);
	void set_next_passphrase( const char *s );
	char *get_last_passphrase(void);
	void next_to_last_passphrase(void);

	void emit_status_need_passphrase (u32 keyid, u32 mainkeyid, int pubkey_algo);

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


	/-- getkey.c --/
	void cache_public_key( PKT_public_key *pk );
	void getkey_disable_caches(void);
	int get_pubkey( PKT_public_key pk, u32 keyid );
	int get_pubkey_fast ( PKT_public_key pk, u32 keyid );
	KBNODE get_pubkeyblock( u32 *keyid );
	int get_pubkey_byname (ctrl_t ctrl,
	GETKEY_CTX rx, PKT_public_key pk, const char *name,
	KBNODE ret_keyblock, KEYDB_HANDLE ret_kdbhd,
	int include_unusable, int no_akl );
	int get_pubkey_bynames( GETKEY_CTX rx, PKT_public_key pk,
	strlist_t names, KBNODE *ret_keyblock );
	int get_pubkey_next( GETKEY_CTX ctx, PKT_public_key pk, KBNODE ret_keyblock );
	void get_pubkey_end( GETKEY_CTX ctx );
	gpg_error_t get_seckey (PKT_public_key pk, u32 keyid);
	gpg_error_t get_pubkey_byfpr (PKT_public_key pk, const byte fpr);
	int get_pubkey_byfprint (PKT_public_key pk, kbnode_t r_keyblock,
	const byte *fprint, size_t fprint_len);
	int get_pubkey_byfprint_fast (PKT_public_key *pk,
	const byte *fprint, size_t fprint_len);
	int get_keyblock_byfprint( KBNODE ret_keyblock, const byte fprint,
	size_t fprint_len );

	int have_secret_key_with_kid (u32 *keyid);

	gpg_error_t get_seckey_byname (PKT_public_key pk, const char name);

	gpg_error_t get_seckey_byfprint (PKT_public_key *pk,
	const byte *fprint, size_t fprint_len);
	gpg_error_t get_seckeyblock_byfprint (kbnode_t *ret_keyblock,
	const byte *fprint, size_t fprint_len);

	gpg_error_t getkey_bynames (getkey_ctx_t retctx, PKT_public_key pk,
	strlist_t names, int want_secret,
	kbnode_t *ret_keyblock);
	gpg_error_t getkey_byname (getkey_ctx_t retctx, PKT_public_key pk,
	const char *name, int want_secret,
	kbnode_t *ret_keyblock);
	gpg_error_t getkey_next (getkey_ctx_t ctx, PKT_public_key *pk,
	kbnode_t *ret_keyblock);
	void getkey_end (getkey_ctx_t ctx);

	gpg_error_t enum_secret_keys (void *context, PKT_public_key pk);

	void setup_main_keyids (kbnode_t keyblock);
	void merge_keys_and_selfsig( KBNODE keyblock );
	charget_user_id_string_native( u32 keyid );
	charget_long_user_id_string( u32 keyid );
	charget_user_id( u32 keyid, size_t *rn );
	charget_user_id_native( u32 keyid );
	char get_user_id_byfpr (const byte fpr, size_t *rn);
	char get_user_id_byfpr_native (const byte fpr);
	KEYDB_HANDLE get_ctx_handle(GETKEY_CTX ctx);
	void release_akl(void);
	int parse_auto_key_locate(char *options);

	/-- keyid.c --/
	int pubkey_letter( int algo );
	char pubkey_string (PKT_public_key pk, char *buffer, size_t bufsize);
	#define PUBKEY_STRING_SIZE 32
	u32 v3_keyid (gcry_mpi_t a, u32 *ki);
	void hash_public_key( gcry_md_hd_t md, PKT_public_key *pk );
	size_t keystrlen(void);
	const char keystr(u32 keyid);
	const char keystr_with_sub (u32 main_kid, u32 *sub_kid);
	const char keystr_from_pk(PKT_public_key pk);
	const char keystr_from_pk_with_sub (PKT_public_key main_pk,
	PKT_public_key *sub_pk);
	const char keystr_from_desc(KEYDB_SEARCH_DESC desc);
	u32 keyid_from_pk( PKT_public_key pk, u32 keyid );
	u32 keyid_from_sig( PKT_signature sig, u32 keyid );
	u32 keyid_from_fingerprint(const byte fprint, size_t fprint_len, u32 keyid);
	byte namehash_from_uid(PKT_user_id uid);
	unsigned nbits_from_pk( PKT_public_key *pk );
	const char datestr_from_pk( PKT_public_key pk );
	const char datestr_from_sig( PKT_signature sig );
	const char expirestr_from_pk( PKT_public_key pk );
	const char expirestr_from_sig( PKT_signature sig );
	const char revokestr_from_pk( PKT_public_key pk );
	const char usagestr_from_pk (PKT_public_key pk, int fill);
	const char *colon_strtime (u32 t);
	const char colon_datestr_from_pk (PKT_public_key pk);
	const char colon_datestr_from_sig (PKT_signature sig);
	const char colon_expirestr_from_sig (PKT_signature sig);
	byte fingerprint_from_pk( PKT_public_key pk, byte buf, size_t ret_len );
	char hexfingerprint (PKT_public_key pk);
	gpg_error_t keygrip_from_pk (PKT_public_key pk, unsigned char array);
	gpg_error_t hexkeygrip_from_pk (PKT_public_key pk, char *r_grip);


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

	#endif /G10_KEYDB_H/

File Metadata

Mime Type: text/x-diff
Expires: Fri, Dec 19, 1:35 PM (6 h, 49 m)
Storage Engine: local-disk
Storage Format: Raw Data
Storage Handle: 95/53/3b25912720a9989043075109e91b

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions