No OneTemporary
Actions

Size

188 KB

Subscribers

None

View Options

	diff --git a/g10/export.c b/g10/export.c
	index 3ce8185e0..92235fbf6 100644
	--- a/g10/export.c
	+++ b/g10/export.c
	@@ -1,2264 +1,2304 @@
	/* export.c - Export keys in the OpenPGP defined format.
	* Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004,
	* 2005, 2010 Free Software Foundation, Inc.
	* Copyright (C) 1998-2016 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 "gpg.h"
	#include "options.h"
	#include "packet.h"
	#include "status.h"
	#include "keydb.h"
	#include "util.h"
	#include "main.h"
	#include "i18n.h"
	#include "membuf.h"
	#include "host2net.h"
	#include "zb32.h"
	#include "recsel.h"
	#include "mbox-util.h"
	#include "init.h"
	#include "trustdb.h"
	#include "call-agent.h"

	/* An object to keep track of subkeys. */
	struct subkey_list_s
	{
	struct subkey_list_s *next;
	u32 kid[2];
	};
	typedef struct subkey_list_s *subkey_list_t;


	/* An object to track statistics for export operations. */
	struct export_stats_s
	{
	ulong count; /* Number of processed keys. */
	ulong secret_count; /* Number of secret keys seen. */
	ulong exported; /* Number of actual exported keys. */
	};


	/* A global variable to store the selector created from
	* --export-filter keep-uid=EXPR.
	*
	* FIXME: We should put this into the CTRL object but that requires a
	* lot more changes right now.
	*/
	static recsel_expr_t export_keep_uid;



	/* Local prototypes. */
	static int do_export (ctrl_t ctrl, strlist_t users, int secret,
	unsigned int options, export_stats_t stats);
	static int do_export_stream (ctrl_t ctrl, iobuf_t out,
	strlist_t users, int secret,
	kbnode_t *keyblock_out, unsigned int options,
	export_stats_t stats, int *any);
	+static gpg_error_t print_pka_or_dane_records
	+/*/ (iobuf_t out, kbnode_t keyblock, PKT_public_key pk,
	+ const void *data, size_t datalen,
	+ int print_pka, int print_dane);


	static void
	cleanup_export_globals (void)
	{
	recsel_release (export_keep_uid);
	export_keep_uid = NULL;
	}


	/* Option parser for export options. See parse_options fro
	details. */
	int
	parse_export_options(char str,unsigned int options,int noisy)
	{
	struct parse_options export_opts[]=
	{
	{"export-local-sigs",EXPORT_LOCAL_SIGS,NULL,
	N_("export signatures that are marked as local-only")},
	{"export-attributes",EXPORT_ATTRIBUTES,NULL,
	N_("export attribute user IDs (generally photo IDs)")},
	{"export-sensitive-revkeys",EXPORT_SENSITIVE_REVKEYS,NULL,
	N_("export revocation keys marked as \"sensitive\"")},
	{"export-clean",EXPORT_CLEAN,NULL,
	N_("remove unusable parts from key during export")},
	{"export-minimal",EXPORT_MINIMAL\|EXPORT_CLEAN,NULL,
	N_("remove as much as possible from key during export")},

	{"export-pka", EXPORT_PKA_FORMAT, NULL, NULL },
	{"export-dane", EXPORT_DANE_FORMAT, NULL, NULL },

	/* Aliases for backward compatibility */
	{"include-local-sigs",EXPORT_LOCAL_SIGS,NULL,NULL},
	{"include-attributes",EXPORT_ATTRIBUTES,NULL,NULL},
	{"include-sensitive-revkeys",EXPORT_SENSITIVE_REVKEYS,NULL,NULL},
	/* dummy */
	{"export-unusable-sigs",0,NULL,NULL},
	{"export-clean-sigs",0,NULL,NULL},
	{"export-clean-uids",0,NULL,NULL},
	{NULL,0,NULL,NULL}
	/* add tags for include revoked and disabled? */
	};

	return parse_options(str,options,export_opts,noisy);
	}


	/* Parse and set an export 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 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 exported. 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_export_filter (const char *string)
	{
	gpg_error_t err;

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

	if (!strncmp (string, "keep-uid=", 9))
	err = recsel_parse_expr (&export_keep_uid, string+9);
	else
	err = gpg_error (GPG_ERR_INV_NAME);

	return err;
	}


	/* Create a new export stats object initialized to zero. On error
	returns NULL and sets ERRNO. */
	export_stats_t
	export_new_stats (void)
	{
	export_stats_t stats;

	return xtrycalloc (1, sizeof *stats);
	}


	/* Release an export stats object. */
	void
	export_release_stats (export_stats_t stats)
	{
	xfree (stats);
	}


	/* Print export statistics using the status interface. */
	void
	export_print_stats (export_stats_t stats)
	{
	if (!stats)
	return;

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

	snprintf (buf, sizeof buf, "%lu %lu %lu",
	stats->count,
	stats->secret_count,
	stats->exported );
	write_status_text (STATUS_EXPORT_RES, buf);
	}
	}


	/*
	* Export public keys (to stdout or to --output FILE).
	*
	* Depending on opt.armor the output is armored. OPTIONS are defined
	* in main.h. If USERS is NULL, all keys will be exported. STATS is
	* either an export stats object for update or NULL.
	*
	* This function is the core of "gpg --export".
	*/
	int
	export_pubkeys (ctrl_t ctrl, strlist_t users, unsigned int options,
	export_stats_t stats)
	{
	return do_export (ctrl, users, 0, options, stats);
	}


	/*
	* Export secret keys (to stdout or to --output FILE).
	*
	* Depending on opt.armor the output is armored. If USERS is NULL,
	* all secret keys will be exported. STATS is either an export stats
	* object for update or NULL.
	*
	* This function is the core of "gpg --export-secret-keys".
	*/
	int
	export_seckeys (ctrl_t ctrl, strlist_t users, export_stats_t stats)
	{
	return do_export (ctrl, users, 1, 0, stats);
	}


	/*
	* Export secret sub keys (to stdout or to --output FILE).
	*
	* This is the same as export_seckeys but replaces the primary key by
	* a stub key. Depending on opt.armor the output is armored. If
	* USERS is NULL, all secret subkeys will be exported. STATS is
	* either an export stats object for update or NULL.
	*
	* This function is the core of "gpg --export-secret-subkeys".
	*/
	int
	export_secsubkeys (ctrl_t ctrl, strlist_t users, export_stats_t stats)
	{
	return do_export (ctrl, users, 2, 0, stats);
	}


	/*
	* Export a single key into a memory buffer. STATS is either an
	* export stats object for update or NULL.
	*/
	gpg_error_t
	export_pubkey_buffer (ctrl_t ctrl, const char *keyspec, unsigned int options,
	export_stats_t stats,
	kbnode_t r_keyblock, void r_data, size_t r_datalen)
	{
	gpg_error_t err;
	iobuf_t iobuf;
	int any;
	strlist_t helplist;

	*r_keyblock = NULL;
	*r_data = NULL;
	*r_datalen = 0;

	helplist = NULL;
	if (!add_to_strlist_try (&helplist, keyspec))
	return gpg_error_from_syserror ();

	iobuf = iobuf_temp ();
	err = do_export_stream (ctrl, iobuf, helplist, 0, r_keyblock, options,
	stats, &any);
	if (!err && !any)
	err = gpg_error (GPG_ERR_NOT_FOUND);
	if (!err)
	{
	const void *src;
	size_t datalen;

	iobuf_flush_temp (iobuf);
	src = iobuf_get_temp_buffer (iobuf);
	datalen = iobuf_get_temp_length (iobuf);
	if (!datalen)
	err = gpg_error (GPG_ERR_NO_PUBKEY);
	else if (!(*r_data = xtrymalloc (datalen)))
	err = gpg_error_from_syserror ();
	else
	{
	memcpy (*r_data, src, datalen);
	*r_datalen = datalen;
	}
	}
	iobuf_close (iobuf);
	free_strlist (helplist);
	if (err && *r_keyblock)
	{
	release_kbnode (*r_keyblock);
	*r_keyblock = NULL;
	}
	return err;
	}


	/* Export the keys identified by the list of strings in USERS. If
	Secret is false public keys will be exported. With secret true
	secret keys will be exported; in this case 1 means the entire
	secret keyblock and 2 only the subkeys. OPTIONS are the export
	options to apply. */
	static int
	do_export (ctrl_t ctrl, strlist_t users, int secret, unsigned int options,
	export_stats_t stats)
	{
	IOBUF out = NULL;
	int any, rc;
	armor_filter_context_t *afx = NULL;
	compress_filter_context_t zfx;

	memset( &zfx, 0, sizeof zfx);

	rc = open_outfile (-1, NULL, 0, !!secret, &out );
	if (rc)
	return rc;

	if ( opt.armor && !(options & (EXPORT_PKA_FORMAT\|EXPORT_DANE_FORMAT)) )
	{
	afx = new_armor_context ();
	afx->what = secret? 5 : 1;
	push_armor_filter (afx, out);
	}

	rc = do_export_stream (ctrl, out, users, secret, NULL, options, stats, &any);

	if ( rc \|\| !any )
	iobuf_cancel (out);
	else
	iobuf_close (out);
	release_armor_context (afx);
	return rc;
	}



	/* Release an entire subkey list. */
	static void
	release_subkey_list (subkey_list_t list)
	{
	while (list)
	{
	subkey_list_t tmp = list->next;;
	xfree (list);
	list = tmp;
	}
	}


	/* Returns true if NODE is a subkey and contained in LIST. */
	static int
	subkey_in_list_p (subkey_list_t list, KBNODE node)
	{
	if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY
	\|\| node->pkt->pkttype == PKT_SECRET_SUBKEY )
	{
	u32 kid[2];

	keyid_from_pk (node->pkt->pkt.public_key, kid);

	for (; list; list = list->next)
	if (list->kid[0] == kid[0] && list->kid[1] == kid[1])
	return 1;
	}
	return 0;
	}

	/* Allocate a new subkey list item from NODE. */
	static subkey_list_t
	new_subkey_list_item (KBNODE node)
	{
	subkey_list_t list = xcalloc (1, sizeof *list);

	if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY
	\|\| node->pkt->pkttype == PKT_SECRET_SUBKEY)
	keyid_from_pk (node->pkt->pkt.public_key, list->kid);

	return list;
	}


	/* Helper function to check whether the subkey at NODE actually
	matches the description at DESC. The function returns true if the
	key under question has been specified by an exact specification
	(keyID or fingerprint) and does match the one at NODE. It is
	assumed that the packet at NODE is either a public or secret
	subkey. */
	static int
	exact_subkey_match_p (KEYDB_SEARCH_DESC *desc, KBNODE node)
	{
	u32 kid[2];
	byte fpr[MAX_FINGERPRINT_LEN];
	size_t fprlen;
	int result = 0;

	switch(desc->mode)
	{
	case KEYDB_SEARCH_MODE_SHORT_KID:
	case KEYDB_SEARCH_MODE_LONG_KID:
	keyid_from_pk (node->pkt->pkt.public_key, kid);
	break;

	case KEYDB_SEARCH_MODE_FPR16:
	case KEYDB_SEARCH_MODE_FPR20:
	case KEYDB_SEARCH_MODE_FPR:
	fingerprint_from_pk (node->pkt->pkt.public_key, fpr,&fprlen);
	break;

	default:
	break;
	}

	switch(desc->mode)
	{
	case KEYDB_SEARCH_MODE_SHORT_KID:
	if (desc->u.kid[1] == kid[1])
	result = 1;
	break;

	case KEYDB_SEARCH_MODE_LONG_KID:
	if (desc->u.kid[0] == kid[0] && desc->u.kid[1] == kid[1])
	result = 1;
	break;

	case KEYDB_SEARCH_MODE_FPR16:
	if (!memcmp (desc->u.fpr, fpr, 16))
	result = 1;
	break;

	case KEYDB_SEARCH_MODE_FPR20:
	case KEYDB_SEARCH_MODE_FPR:
	if (!memcmp (desc->u.fpr, fpr, 20))
	result = 1;
	break;

	default:
	break;
	}

	return result;
	}


	/* Return an error if the key represented by the S-expression S_KEY
	* and the OpenPGP key represented by PK do not use the same curve. */
	static gpg_error_t
	match_curve_skey_pk (gcry_sexp_t s_key, PKT_public_key *pk)
	{
	gcry_sexp_t curve = NULL;
	gcry_sexp_t flags = NULL;
	char *curve_str = NULL;
	char *flag;
	const char *oidstr = NULL;
	gcry_mpi_t curve_as_mpi = NULL;
	gpg_error_t err;
	int is_eddsa = 0;
	int idx = 0;

	if (!(pk->pubkey_algo==PUBKEY_ALGO_ECDH
	\|\| pk->pubkey_algo==PUBKEY_ALGO_ECDSA
	\|\| pk->pubkey_algo==PUBKEY_ALGO_EDDSA))
	return gpg_error (GPG_ERR_PUBKEY_ALGO);

	curve = gcry_sexp_find_token (s_key, "curve", 0);
	if (!curve)
	{
	log_error ("no reported curve\n");
	return gpg_error (GPG_ERR_UNKNOWN_CURVE);
	}
	curve_str = gcry_sexp_nth_string (curve, 1);
	gcry_sexp_release (curve); curve = NULL;
	if (!curve_str)
	{
	log_error ("no curve name\n");
	return gpg_error (GPG_ERR_UNKNOWN_CURVE);
	}
	oidstr = openpgp_curve_to_oid (curve_str, NULL);
	if (!oidstr)
	{
	log_error ("no OID known for curve '%s'\n", curve_str);
	xfree (curve_str);
	return gpg_error (GPG_ERR_UNKNOWN_CURVE);
	}
	xfree (curve_str);
	err = openpgp_oid_from_str (oidstr, &curve_as_mpi);
	if (err)
	return err;
	if (gcry_mpi_cmp (pk->pkey[0], curve_as_mpi))
	{
	log_error ("curves do not match\n");
	gcry_mpi_release (curve_as_mpi);
	return gpg_error (GPG_ERR_INV_CURVE);
	}
	gcry_mpi_release (curve_as_mpi);
	flags = gcry_sexp_find_token (s_key, "flags", 0);
	if (flags)
	{
	for (idx = 1; idx < gcry_sexp_length (flags); idx++)
	{
	flag = gcry_sexp_nth_string (flags, idx);
	if (flag && (strcmp ("eddsa", flag) == 0))
	is_eddsa = 1;
	gcry_free (flag);
	}
	}
	if (is_eddsa != (pk->pubkey_algo == PUBKEY_ALGO_EDDSA))
	{
	log_error ("disagreement about EdDSA\n");
	err = gpg_error (GPG_ERR_INV_CURVE);
	}

	return err;
	}


	/* Return a canonicalized public key algoithms. This is used to
	compare different flavors of algorithms (e.g. ELG and ELG_E are
	considered the same). */
	static enum gcry_pk_algos
	canon_pk_algo (enum gcry_pk_algos algo)
	{
	switch (algo)
	{
	case GCRY_PK_RSA:
	case GCRY_PK_RSA_E:
	case GCRY_PK_RSA_S: return GCRY_PK_RSA;
	case GCRY_PK_ELG:
	case GCRY_PK_ELG_E: return GCRY_PK_ELG;
	case GCRY_PK_ECC:
	case GCRY_PK_ECDSA:
	case GCRY_PK_ECDH: return GCRY_PK_ECC;
	default: return algo;
	}
	}


	/* Take a cleartext dump of a secret key in PK and change the
	* parameter array in PK to include the secret parameters. */
	static gpg_error_t
	cleartext_secret_key_to_openpgp (gcry_sexp_t s_key, PKT_public_key *pk)
	{
	gpg_error_t err = gpg_error (GPG_ERR_NOT_IMPLEMENTED);
	gcry_sexp_t top_list;
	gcry_sexp_t key = NULL;
	char *key_type = NULL;
	enum gcry_pk_algos pk_algo;
	struct seckey_info *ski;
	int idx, sec_start;
	gcry_mpi_t pub_params[10] = { NULL };

	/* we look for a private-key, then the first element in it tells us
	the type */
	top_list = gcry_sexp_find_token (s_key, "private-key", 0);
	if (!top_list)
	goto bad_seckey;
	if (gcry_sexp_length(top_list) != 2)
	goto bad_seckey;
	key = gcry_sexp_nth (top_list, 1);
	if (!key)
	goto bad_seckey;
	key_type = gcry_sexp_nth_string(key, 0);
	pk_algo = gcry_pk_map_name (key_type);

	log_assert (!pk->seckey_info);

	pk->seckey_info = ski = xtrycalloc (1, sizeof *ski);
	if (!ski)
	{
	err = gpg_error_from_syserror ();
	goto leave;
	}

	switch (canon_pk_algo (pk_algo))
	{
	case GCRY_PK_RSA:
	if (!is_RSA (pk->pubkey_algo))
	goto bad_pubkey_algo;
	err = gcry_sexp_extract_param (key, NULL, "ne",
	&pub_params[0],
	&pub_params[1],
	NULL);
	for (idx=0; idx < 2 && !err; idx++)
	if (gcry_mpi_cmp(pk->pkey[idx], pub_params[idx]))
	err = gpg_error (GPG_ERR_BAD_PUBKEY);
	if (!err)
	{
	for (idx = 2; idx < 6 && !err; idx++)
	{
	gcry_mpi_release (pk->pkey[idx]);
	pk->pkey[idx] = NULL;
	}
	err = gcry_sexp_extract_param (key, NULL, "dpqu",
	&pk->pkey[2],
	&pk->pkey[3],
	&pk->pkey[4],
	&pk->pkey[5],
	NULL);
	}
	if (!err)
	{
	for (idx = 2; idx < 6; idx++)
	ski->csum += checksum_mpi (pk->pkey[idx]);
	}
	break;

	case GCRY_PK_DSA:
	if (!is_DSA (pk->pubkey_algo))
	goto bad_pubkey_algo;
	err = gcry_sexp_extract_param (key, NULL, "pqgy",
	&pub_params[0],
	&pub_params[1],
	&pub_params[2],
	&pub_params[3],
	NULL);
	for (idx=0; idx < 4 && !err; idx++)
	if (gcry_mpi_cmp(pk->pkey[idx], pub_params[idx]))
	err = gpg_error (GPG_ERR_BAD_PUBKEY);
	if (!err)
	{
	gcry_mpi_release (pk->pkey[4]);
	pk->pkey[4] = NULL;
	err = gcry_sexp_extract_param (key, NULL, "x",
	&pk->pkey[4],
	NULL);
	}
	if (!err)
	ski->csum += checksum_mpi (pk->pkey[4]);
	break;

	case GCRY_PK_ELG:
	if (!is_ELGAMAL (pk->pubkey_algo))
	goto bad_pubkey_algo;
	err = gcry_sexp_extract_param (key, NULL, "pgy",
	&pub_params[0],
	&pub_params[1],
	&pub_params[2],
	NULL);
	for (idx=0; idx < 3 && !err; idx++)
	if (gcry_mpi_cmp(pk->pkey[idx], pub_params[idx]))
	err = gpg_error (GPG_ERR_BAD_PUBKEY);
	if (!err)
	{
	gcry_mpi_release (pk->pkey[3]);
	pk->pkey[3] = NULL;
	err = gcry_sexp_extract_param (key, NULL, "x",
	&pk->pkey[3],
	NULL);
	}
	if (!err)
	ski->csum += checksum_mpi (pk->pkey[3]);
	break;

	case GCRY_PK_ECC:
	err = match_curve_skey_pk (key, pk);
	if (err)
	goto leave;
	if (!err)
	err = gcry_sexp_extract_param (key, NULL, "q",
	&pub_params[0],
	NULL);
	if (!err && (gcry_mpi_cmp(pk->pkey[1], pub_params[0])))
	err = gpg_error (GPG_ERR_BAD_PUBKEY);

	sec_start = 2;
	if (pk->pubkey_algo == PUBKEY_ALGO_ECDH)
	sec_start += 1;
	if (!err)
	{
	gcry_mpi_release (pk->pkey[sec_start]);
	pk->pkey[sec_start] = NULL;
	err = gcry_sexp_extract_param (key, NULL, "d",
	&pk->pkey[sec_start],
	NULL);
	}

	if (!err)
	ski->csum += checksum_mpi (pk->pkey[sec_start]);
	break;

	default:
	pk->seckey_info = NULL;
	xfree (ski);
	err = gpg_error (GPG_ERR_NOT_IMPLEMENTED);
	break;
	}

	leave:
	gcry_sexp_release (top_list);
	gcry_sexp_release (key);
	gcry_free (key_type);

	for (idx=0; idx < DIM(pub_params); idx++)
	gcry_mpi_release (pub_params[idx]);
	return err;

	bad_pubkey_algo:
	err = gpg_error (GPG_ERR_PUBKEY_ALGO);
	goto leave;

	bad_seckey:
	err = gpg_error (GPG_ERR_BAD_SECKEY);
	goto leave;
	}


	/* Use the key transfer format given in S_PGP to create the secinfo
	structure in PK and change the parameter array in PK to include the
	secret parameters. */
	static gpg_error_t
	transfer_format_to_openpgp (gcry_sexp_t s_pgp, PKT_public_key *pk)
	{
	gpg_error_t err;
	gcry_sexp_t top_list;
	gcry_sexp_t list = NULL;
	char *curve = NULL;
	const char *value;
	size_t valuelen;
	char *string;
	int idx;
	int is_v4, is_protected;
	enum gcry_pk_algos pk_algo;
	int protect_algo = 0;
	char iv[16];
	int ivlen = 0;
	int s2k_mode = 0;
	int s2k_algo = 0;
	byte s2k_salt[8];
	u32 s2k_count = 0;
	int is_ecdh = 0;
	size_t npkey, nskey;
	gcry_mpi_t skey[10]; /* We support up to 9 parameters. */
	int skeyidx = 0;
	struct seckey_info *ski;

	/* gcry_log_debugsxp ("transferkey", s_pgp); */
	top_list = gcry_sexp_find_token (s_pgp, "openpgp-private-key", 0);
	if (!top_list)
	goto bad_seckey;

	list = gcry_sexp_find_token (top_list, "version", 0);
	if (!list)
	goto bad_seckey;
	value = gcry_sexp_nth_data (list, 1, &valuelen);
	if (!value \|\| valuelen != 1 \|\| !(value[0] == '3' \|\| value[0] == '4'))
	goto bad_seckey;
	is_v4 = (value[0] == '4');

	gcry_sexp_release (list);
	list = gcry_sexp_find_token (top_list, "protection", 0);
	if (!list)
	goto bad_seckey;
	value = gcry_sexp_nth_data (list, 1, &valuelen);
	if (!value)
	goto bad_seckey;
	if (valuelen == 4 && !memcmp (value, "sha1", 4))
	is_protected = 2;
	else if (valuelen == 3 && !memcmp (value, "sum", 3))
	is_protected = 1;
	else if (valuelen == 4 && !memcmp (value, "none", 4))
	is_protected = 0;
	else
	goto bad_seckey;
	if (is_protected)
	{
	string = gcry_sexp_nth_string (list, 2);
	if (!string)
	goto bad_seckey;
	protect_algo = gcry_cipher_map_name (string);
	xfree (string);

	value = gcry_sexp_nth_data (list, 3, &valuelen);
	if (!value \|\| !valuelen \|\| valuelen > sizeof iv)
	goto bad_seckey;
	memcpy (iv, value, valuelen);
	ivlen = valuelen;

	string = gcry_sexp_nth_string (list, 4);
	if (!string)
	goto bad_seckey;
	s2k_mode = strtol (string, NULL, 10);
	xfree (string);

	string = gcry_sexp_nth_string (list, 5);
	if (!string)
	goto bad_seckey;
	s2k_algo = gcry_md_map_name (string);
	xfree (string);

	value = gcry_sexp_nth_data (list, 6, &valuelen);
	if (!value \|\| !valuelen \|\| valuelen > sizeof s2k_salt)
	goto bad_seckey;
	memcpy (s2k_salt, value, valuelen);

	string = gcry_sexp_nth_string (list, 7);
	if (!string)
	goto bad_seckey;
	s2k_count = strtoul (string, NULL, 10);
	xfree (string);
	}

	/* Parse the gcrypt PK algo and check that it is okay. */
	gcry_sexp_release (list);
	list = gcry_sexp_find_token (top_list, "algo", 0);
	if (!list)
	goto bad_seckey;
	string = gcry_sexp_nth_string (list, 1);
	if (!string)
	goto bad_seckey;
	pk_algo = gcry_pk_map_name (string);
	xfree (string); string = NULL;
	if (gcry_pk_algo_info (pk_algo, GCRYCTL_GET_ALGO_NPKEY, NULL, &npkey)
	\|\| gcry_pk_algo_info (pk_algo, GCRYCTL_GET_ALGO_NSKEY, NULL, &nskey)
	\|\| !npkey \|\| npkey >= nskey)
	goto bad_seckey;

	/* Check that the pubkey algo matches the one from the public key. */
	switch (canon_pk_algo (pk_algo))
	{
	case GCRY_PK_RSA:
	if (!is_RSA (pk->pubkey_algo))
	pk_algo = 0; /* Does not match. */
	break;
	case GCRY_PK_DSA:
	if (!is_DSA (pk->pubkey_algo))
	pk_algo = 0; /* Does not match. */
	break;
	case GCRY_PK_ELG:
	if (!is_ELGAMAL (pk->pubkey_algo))
	pk_algo = 0; /* Does not match. */
	break;
	case GCRY_PK_ECC:
	if (pk->pubkey_algo == PUBKEY_ALGO_ECDSA)
	;
	else if (pk->pubkey_algo == PUBKEY_ALGO_ECDH)
	is_ecdh = 1;
	else if (pk->pubkey_algo == PUBKEY_ALGO_EDDSA)
	;
	else
	pk_algo = 0; /* Does not match. */
	/* For ECC we do not have the domain parameters thus fix our info. */
	npkey = 1;
	nskey = 2;
	break;
	default:
	pk_algo = 0; /* Oops. */
	break;
	}
	if (!pk_algo)
	{
	err = gpg_error (GPG_ERR_PUBKEY_ALGO);
	goto leave;
	}

	/* This check has to go after the ecc adjustments. */
	if (nskey > PUBKEY_MAX_NSKEY)
	goto bad_seckey;

	/* Parse the key parameters. */
	gcry_sexp_release (list);
	list = gcry_sexp_find_token (top_list, "skey", 0);
	if (!list)
	goto bad_seckey;
	for (idx=0;;)
	{
	int is_enc;

	value = gcry_sexp_nth_data (list, ++idx, &valuelen);
	if (!value && skeyidx >= npkey)
	break; /* Ready. */

	/* Check for too many parameters. Note that depending on the
	protection mode and version number we may see less than NSKEY
	(but at least NPKEY+1) parameters. */
	if (idx >= 2*nskey)
	goto bad_seckey;
	if (skeyidx >= DIM (skey)-1)
	goto bad_seckey;

	if (!value \|\| valuelen != 1 \|\| !(value[0] == '_' \|\| value[0] == 'e'))
	goto bad_seckey;
	is_enc = (value[0] == 'e');
	value = gcry_sexp_nth_data (list, ++idx, &valuelen);
	if (!value \|\| !valuelen)
	goto bad_seckey;
	if (is_enc)
	{
	void *p = xtrymalloc (valuelen);
	if (!p)
	goto outofmem;
	memcpy (p, value, valuelen);
	skey[skeyidx] = gcry_mpi_set_opaque (NULL, p, valuelen*8);
	if (!skey[skeyidx])
	goto outofmem;
	}
	else
	{
	if (gcry_mpi_scan (skey + skeyidx, GCRYMPI_FMT_STD,
	value, valuelen, NULL))
	goto bad_seckey;
	}
	skeyidx++;
	}
	skey[skeyidx++] = NULL;

	gcry_sexp_release (list); list = NULL;

	/* We have no need for the CSUM value thus we don't parse it. */
	/* list = gcry_sexp_find_token (top_list, "csum", 0); */
	/* if (list) */
	/* { */
	/* string = gcry_sexp_nth_string (list, 1); */
	/* if (!string) */
	/* goto bad_seckey; */
	/* desired_csum = strtoul (string, NULL, 10); */
	/* xfree (string); */
	/* } */
	/* else */
	/* desired_csum = 0; */
	/* gcry_sexp_release (list); list = NULL; */

	/* Get the curve name if any, */
	list = gcry_sexp_find_token (top_list, "curve", 0);
	if (list)
	{
	curve = gcry_sexp_nth_string (list, 1);
	gcry_sexp_release (list); list = NULL;
	}

	gcry_sexp_release (top_list); top_list = NULL;

	/* log_debug ("XXX is_v4=%d\n", is_v4); */
	/* log_debug ("XXX pubkey_algo=%d\n", pubkey_algo); */
	/* log_debug ("XXX is_protected=%d\n", is_protected); */
	/* log_debug ("XXX protect_algo=%d\n", protect_algo); */
	/* log_printhex ("XXX iv", iv, ivlen); */
	/* log_debug ("XXX ivlen=%d\n", ivlen); */
	/* log_debug ("XXX s2k_mode=%d\n", s2k_mode); */
	/* log_debug ("XXX s2k_algo=%d\n", s2k_algo); */
	/* log_printhex ("XXX s2k_salt", s2k_salt, sizeof s2k_salt); */
	/* log_debug ("XXX s2k_count=%lu\n", (unsigned long)s2k_count); */
	/* for (idx=0; skey[idx]; idx++) */
	/* { */
	/* int is_enc = gcry_mpi_get_flag (skey[idx], GCRYMPI_FLAG_OPAQUE); */
	/* log_info ("XXX skey[%d]%s:", idx, is_enc? " (enc)":""); */
	/* if (is_enc) */
	/* { */
	/* void p; /
	/* unsigned int nbits; */
	/* p = gcry_mpi_get_opaque (skey[idx], &nbits); */
	/* log_printhex (NULL, p, (nbits+7)/8); */
	/* } */
	/* else */
	/* gcry_mpi_dump (skey[idx]); */
	/* log_printf ("\n"); */
	/* } */

	if (!is_v4 \|\| is_protected != 2 )
	{
	/* We only support the v4 format and a SHA-1 checksum. */
	err = gpg_error (GPG_ERR_NOT_IMPLEMENTED);
	goto leave;
	}

	/* We need to change the received parameters for ECC algorithms.
	The transfer format has the curve name and the parameters
	separate. We put them all into the SKEY array. */
	if (canon_pk_algo (pk_algo) == GCRY_PK_ECC)
	{
	const char *oidstr;

	/* Assert that all required parameters are available. We also
	check that the array does not contain more parameters than
	needed (this was used by some beta versions of 2.1. */
	if (!curve \|\| !skey[0] \|\| !skey[1] \|\| skey[2])
	{
	err = gpg_error (GPG_ERR_INTERNAL);
	goto leave;
	}

	oidstr = openpgp_curve_to_oid (curve, NULL);
	if (!oidstr)
	{
	log_error ("no OID known for curve '%s'\n", curve);
	err = gpg_error (GPG_ERR_UNKNOWN_CURVE);
	goto leave;
	}
	/* Put the curve's OID into into the MPI array. This requires
	that we shift Q and D. For ECDH also insert the KDF parms. */
	if (is_ecdh)
	{
	skey[4] = NULL;
	skey[3] = skey[1];
	skey[2] = gcry_mpi_copy (pk->pkey[2]);
	}
	else
	{
	skey[3] = NULL;
	skey[2] = skey[1];
	}
	skey[1] = skey[0];
	skey[0] = NULL;
	err = openpgp_oid_from_str (oidstr, skey + 0);
	if (err)
	goto leave;
	/* Fixup the NPKEY and NSKEY to match OpenPGP reality. */
	npkey = 2 + is_ecdh;
	nskey = 3 + is_ecdh;

	/* for (idx=0; skey[idx]; idx++) */
	/* { */
	/* log_info ("YYY skey[%d]:", idx); */
	/* if (gcry_mpi_get_flag (skey[idx], GCRYMPI_FLAG_OPAQUE)) */
	/* { */
	/* void p; /
	/* unsigned int nbits; */
	/* p = gcry_mpi_get_opaque (skey[idx], &nbits); */
	/* log_printhex (NULL, p, (nbits+7)/8); */
	/* } */
	/* else */
	/* gcry_mpi_dump (skey[idx]); */
	/* log_printf ("\n"); */
	/* } */
	}

	/* Do some sanity checks. */
	if (s2k_count > 255)
	{
	/* We expect an already encoded S2K count. */
	err = gpg_error (GPG_ERR_INV_DATA);
	goto leave;
	}
	err = openpgp_cipher_test_algo (protect_algo);
	if (err)
	goto leave;
	err = openpgp_md_test_algo (s2k_algo);
	if (err)
	goto leave;

	/* Check that the public key parameters match. Note that since
	Libgcrypt 1.5 gcry_mpi_cmp handles opaque MPI correctly. */
	for (idx=0; idx < npkey; idx++)
	if (gcry_mpi_cmp (pk->pkey[idx], skey[idx]))
	{
	err = gpg_error (GPG_ERR_BAD_PUBKEY);
	goto leave;
	}

	/* Check that the first secret key parameter in SKEY is encrypted
	and that there are no more secret key parameters. The latter is
	guaranteed by the v4 packet format. */
	if (!gcry_mpi_get_flag (skey[npkey], GCRYMPI_FLAG_OPAQUE))
	goto bad_seckey;
	if (npkey+1 < DIM (skey) && skey[npkey+1])
	goto bad_seckey;

	/* Check that the secret key parameters in PK are all set to NULL. */
	for (idx=npkey; idx < nskey; idx++)
	if (pk->pkey[idx])
	goto bad_seckey;

	/* Now build the protection info. */
	pk->seckey_info = ski = xtrycalloc (1, sizeof *ski);
	if (!ski)
	{
	err = gpg_error_from_syserror ();
	goto leave;
	}

	ski->is_protected = 1;
	ski->sha1chk = 1;
	ski->algo = protect_algo;
	ski->s2k.mode = s2k_mode;
	ski->s2k.hash_algo = s2k_algo;
	log_assert (sizeof ski->s2k.salt == sizeof s2k_salt);
	memcpy (ski->s2k.salt, s2k_salt, sizeof s2k_salt);
	ski->s2k.count = s2k_count;
	log_assert (ivlen <= sizeof ski->iv);
	memcpy (ski->iv, iv, ivlen);
	ski->ivlen = ivlen;

	/* Store the protected secret key parameter. */
	pk->pkey[npkey] = skey[npkey];
	skey[npkey] = NULL;

	/* That's it. */

	leave:
	gcry_free (curve);
	gcry_sexp_release (list);
	gcry_sexp_release (top_list);
	for (idx=0; idx < skeyidx; idx++)
	gcry_mpi_release (skey[idx]);
	return err;

	bad_seckey:
	err = gpg_error (GPG_ERR_BAD_SECKEY);
	goto leave;

	outofmem:
	err = gpg_error (GPG_ERR_ENOMEM);
	goto leave;
	}


	/* Print an "EXPORTED" status line. PK is the primary public key. */
	static void
	print_status_exported (PKT_public_key *pk)
	{
	char *hexfpr;

	if (!is_status_enabled ())
	return;

	hexfpr = hexfingerprint (pk, NULL, 0);
	write_status_text (STATUS_EXPORTED, hexfpr? hexfpr : "[?]");
	xfree (hexfpr);
	}


	/*
	* Receive a secret key from agent specified by HEXGRIP.
	*
	* Since the key data from agant is encrypted, decrypt it by CIPHERHD.
	* Then, parse the decrypted key data in transfer format, and put
	* secret parameters into PK.
	*
	* If CLEARTEXT is 0, store the secret key material
	* passphrase-protected. Otherwise, store secret key material in the
	* clear.
	*
	* CACHE_NONCE_ADDR is used to share nonce for multple key retrievals.
	*/
	gpg_error_t
	receive_seckey_from_agent (ctrl_t ctrl, gcry_cipher_hd_t cipherhd,
	int cleartext,
	char *cache_nonce_addr, const char hexgrip,
	PKT_public_key *pk)
	{
	gpg_error_t err = 0;
	unsigned char *wrappedkey = NULL;
	size_t wrappedkeylen;
	unsigned char *key = NULL;
	size_t keylen, realkeylen;
	gcry_sexp_t s_skey;
	char *prompt;

	if (opt.verbose)
	log_info ("key %s: asking agent for the secret parts\n", hexgrip);

	prompt = gpg_format_keydesc (pk, FORMAT_KEYDESC_EXPORT,1);
	err = agent_export_key (ctrl, hexgrip, prompt, !cleartext, cache_nonce_addr,
	&wrappedkey, &wrappedkeylen);
	xfree (prompt);

	if (err)
	goto unwraperror;
	if (wrappedkeylen < 24)
	{
	err = gpg_error (GPG_ERR_INV_LENGTH);
	goto unwraperror;
	}
	keylen = wrappedkeylen - 8;
	key = xtrymalloc_secure (keylen);
	if (!key)
	{
	err = gpg_error_from_syserror ();
	goto unwraperror;
	}
	err = gcry_cipher_decrypt (cipherhd, key, keylen, wrappedkey, wrappedkeylen);
	if (err)
	goto unwraperror;
	realkeylen = gcry_sexp_canon_len (key, keylen, NULL, &err);
	if (!realkeylen)
	goto unwraperror; /* Invalid csexp. */

	err = gcry_sexp_sscan (&s_skey, NULL, key, realkeylen);
	if (!err)
	{
	if (cleartext)
	err = cleartext_secret_key_to_openpgp (s_skey, pk);
	else
	err = transfer_format_to_openpgp (s_skey, pk);
	gcry_sexp_release (s_skey);
	}

	unwraperror:
	xfree (key);
	xfree (wrappedkey);
	if (err)
	{
	log_error ("key %s: error receiving key from agent:"
	" %s%s\n", hexgrip, gpg_strerror (err),
	gpg_err_code (err) == GPG_ERR_FULLY_CANCELED?
	"":_(" - skipped"));
	}
	return err;
	}


	/* Write KEYBLOCK either to stdout or to the file set with the
	- * --output option. */
	+ * --output option. This is a simplified version of do_export_stream
	+ * which supports only a few export options. */
	gpg_error_t
	-write_keyblock_to_output (kbnode_t keyblock, int with_armor)
	+write_keyblock_to_output (kbnode_t keyblock, int with_armor,
	+ unsigned int options)
	{
	gpg_error_t err;
	const char *fname;
	iobuf_t out;
	kbnode_t node;
	armor_filter_context_t *afx = NULL;
	+ iobuf_t out_help = NULL;
	+ PKT_public_key *pk = NULL;

	fname = opt.outfile? opt.outfile : "-";
	if (is_secured_filename (fname) )
	return gpg_error (GPG_ERR_EPERM);

	out = iobuf_create (fname, 0);
	if (!out)
	{
	err = gpg_error_from_syserror ();
	log_error(_("can't create '%s': %s\n"), fname, gpg_strerror (err));
	return err;
	}
	if (opt.verbose)
	log_info (_("writing to '%s'\n"), iobuf_get_fname_nonnull (out));

	+ if ((options & (EXPORT_PKA_FORMAT\|EXPORT_DANE_FORMAT)))
	+ {
	+ with_armor = 0;
	+ out_help = iobuf_temp ();
	+ }
	+
	if (with_armor)
	{
	afx = new_armor_context ();
	afx->what = 1;
	push_armor_filter (afx, out);
	}

	for (node = keyblock; node; node = node->next)
	{
	- if (!is_deleted_kbnode (node) && node->pkt->pkttype != PKT_RING_TRUST)
	- {
	- err = build_packet (out, node->pkt);
	- if (err)
	- {
	- log_error ("build_packet(%d) failed: %s\n",
	- node->pkt->pkttype, gpg_strerror (err) );
	- goto leave;
	- }
	- }
	+ if (is_deleted_kbnode (node) \|\| node->pkt->pkttype == PKT_RING_TRUST)
	+ continue;
	+ if (!pk && (node->pkt->pkttype == PKT_PUBLIC_KEY
	+ \|\| node->pkt->pkttype == PKT_SECRET_KEY))
	+ pk = node->pkt->pkt.public_key;
	+
	+ err = build_packet (out_help? out_help : out, node->pkt);
	+ if (err)
	+ {
	+ log_error ("build_packet(%d) failed: %s\n",
	+ node->pkt->pkttype, gpg_strerror (err) );
	+ goto leave;
	+ }
	}
	err = 0;

	+ if (out_help && pk)
	+ {
	+ const void *data;
	+ size_t datalen;
	+
	+ iobuf_flush_temp (out_help);
	+ data = iobuf_get_temp_buffer (out_help);
	+ datalen = iobuf_get_temp_length (out_help);
	+
	+ err = print_pka_or_dane_records (out,
	+ keyblock, pk, data, datalen,
	+ (options & EXPORT_PKA_FORMAT),
	+ (options & EXPORT_DANE_FORMAT));
	+ }
	+
	leave:
	if (err)
	iobuf_cancel (out);
	else
	iobuf_close (out);
	+ iobuf_cancel (out_help);
	release_armor_context (afx);
	return err;
	}


	/* Helper for apply_keep_uid_filter. */
	static const char *
	filter_getval (void cookie, const char propname)
	{
	kbnode_t node = cookie;
	const char *result;

	if (node->pkt->pkttype == PKT_USER_ID)
	{
	if (!strcmp (propname, "uid"))
	result = node->pkt->pkt.user_id->name;
	else if (!strcmp (propname, "mbox"))
	{
	if (!node->pkt->pkt.user_id->mbox)
	{
	node->pkt->pkt.user_id->mbox
	= mailbox_from_userid (node->pkt->pkt.user_id->name);
	}
	return node->pkt->pkt.user_id->mbox;
	}
	else if (!strcmp (propname, "primary"))
	result = node->pkt->pkt.user_id->is_primary? "1":"0";
	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 (kbnode_t keyblock, recsel_expr_t selector)
	{
	kbnode_t node;

	for (node = keyblock->next; node; node = node->next )
	{
	if (node->pkt->pkttype == PKT_USER_ID)
	{
	if (!recsel_select (selector, filter_getval, node))
	{
	/* 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); */
	}
	}
	}


	-/* Print DANE or PKA records for all user IDs in KEYBLOCK to the
	- * stream FP. The data for the record is taken from HEXDATA. HEXFPR
	- * is the fingerprint of the primary key. */
	+/* Print DANE or PKA records for all user IDs in KEYBLOCK to OUT. The
	+ * data for the record is taken from (DATA,DATELEN). PK is the public
	+ * key packet with the primary key. */
	static gpg_error_t
	-print_pka_or_dane_records (kbnode_t keyblock, const char *hexdata,
	- const char *hexfpr, estream_t fp,
	+print_pka_or_dane_records (iobuf_t out, kbnode_t keyblock, PKT_public_key *pk,
	+ const void *data, size_t datalen,
	int print_pka, int print_dane)
	{
	gpg_error_t err = 0;
	kbnode_t kbctx, node;
	PKT_user_id *uid;
	char *mbox = NULL;
	char hashbuf[32];
	char *hash = NULL;
	char *domain;
	const char *s;
	unsigned int len;
	+ estream_t fp = NULL;
	+ char *hexdata = NULL;
	+ char *hexfpr;
	+
	+ hexfpr = hexfingerprint (pk, NULL, 0);
	+ hexdata = bin2hex (data, datalen, NULL);
	+ if (!hexdata)
	+ {
	+ err = gpg_error_from_syserror ();
	+ goto leave;
	+ }
	+ ascii_strlwr (hexdata);
	+ fp = es_fopenmem (0, "rw,samethread");
	+ if (!fp)
	+ {
	+ err = gpg_error_from_syserror ();
	+ goto leave;
	+ }

	for (kbctx = NULL; (node = walk_kbnode (keyblock, &kbctx, 0));)
	{
	if (node->pkt->pkttype != PKT_USER_ID)
	continue;
	uid = node->pkt->pkt.user_id;

	if (uid->is_expired \|\| uid->is_revoked)
	continue;

	xfree (mbox);
	mbox = mailbox_from_userid (uid->name);
	if (!mbox)
	continue;

	domain = strchr (mbox, '@');
	*domain++ = 0;

	if (print_pka)
	{
	es_fprintf (fp, "$ORIGIN _pka.%s.\n; %s\n; ", domain, hexfpr);
	print_utf8_buffer (fp, uid->name, uid->len);
	es_putc ('\n', fp);
	gcry_md_hash_buffer (GCRY_MD_SHA1, hashbuf, mbox, strlen (mbox));
	xfree (hash);
	hash = zb32_encode (hashbuf, 8*20);
	if (!hash)
	{
	err = gpg_error_from_syserror ();
	goto leave;
	}
	len = strlen (hexfpr)/2;
	es_fprintf (fp, "%s TYPE37 \\# %u 0006 0000 00 %02X %s\n\n",
	hash, 6 + len, len, hexfpr);
	}

	if (print_dane && hexdata)
	{
	es_fprintf (fp, "$ORIGIN _openpgpkey.%s.\n; %s\n; ", domain, hexfpr);
	print_utf8_buffer (fp, uid->name, uid->len);
	es_putc ('\n', fp);
	gcry_md_hash_buffer (GCRY_MD_SHA256, hashbuf, mbox, strlen (mbox));
	xfree (hash);
	hash = bin2hex (hashbuf, 28, NULL);
	if (!hash)
	{
	err = gpg_error_from_syserror ();
	goto leave;
	}
	ascii_strlwr (hash);
	len = strlen (hexdata)/2;
	es_fprintf (fp, "%s TYPE61 \\# %u (\n", hash, len);
	for (s = hexdata; ;)
	{
	es_fprintf (fp, "\t%.64s\n", s);
	if (strlen (s) < 64)
	break;
	s += 64;
	}
	es_fputs ("\t)\n\n", fp);
	}
	}

	+ /* Make sure it is a string and write it. */
	+ es_fputc (0, fp);
	+ {
	+ void *vp;
	+
	+ if (es_fclose_snatch (fp, &vp, NULL))
	+ {
	+ err = gpg_error_from_syserror ();
	+ goto leave;
	+ }
	+ fp = NULL;
	+ iobuf_writestr (out, vp);
	+ es_free (vp);
	+ }
	+ err = 0;
	+
	leave:
	xfree (hash);
	xfree (mbox);
	+ es_fclose (fp);
	+ xfree (hexdata);
	+ xfree (hexfpr);
	return err;
	}


	/* Helper for do_export_stream which writes one keyblock to OUT. */
	static gpg_error_t
	do_export_one_keyblock (ctrl_t ctrl, kbnode_t keyblock, u32 *keyid,
	iobuf_t out, int secret, unsigned int options,
	export_stats_t stats, int *any,
	KEYDB_SEARCH_DESC *desc, size_t ndesc,
	size_t descindex, gcry_cipher_hd_t cipherhd)
	{
	gpg_error_t err;
	char *cache_nonce = NULL;
	subkey_list_t subkey_list = NULL; /* Track already processed subkeys. */
	int skip_until_subkey = 0;
	int cleartext = 0;
	char *hexgrip = NULL;
	char *serialno = NULL;
	PKT_public_key *pk;
	u32 subkidbuf[2], *subkid;
	kbnode_t kbctx, node;

	for (kbctx=NULL; (node = walk_kbnode (keyblock, &kbctx, 0)); )
	{
	if (skip_until_subkey)
	{
	if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
	skip_until_subkey = 0;
	else
	continue;
	}

	/* We used to use comment packets, but not any longer. In
	* case we still have comments on a key, strip them here
	* before we call build_packet(). */
	if (node->pkt->pkttype == PKT_COMMENT)
	continue;

	/* Make sure that ring_trust packets never get exported. */
	if (node->pkt->pkttype == PKT_RING_TRUST)
	continue;

	/* If exact is set, then we only export what was requested
	* (plus the primary key, if the user didn't specifically
	* request it). */
	if (desc[descindex].exact && node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
	{
	if (!exact_subkey_match_p (desc+descindex, node))
	{
	/* Before skipping this subkey, check whether any
	* other description wants an exact match on a
	* subkey and include that subkey into the output
	* too. Need to add this subkey to a list so that
	* it won't get processed a second time.
	*
	* So the first step here is to check that list and
	* skip in any case if the key is in that list.
	*
	* We need this whole mess because the import
	* function of GnuPG < 2.1 is not able to merge
	* secret keys and thus it is useless to output them
	* as two separate keys and have import merge them.
	*/
	if (subkey_in_list_p (subkey_list, node))
	skip_until_subkey = 1; /* Already processed this one. */
	else
	{
	size_t j;

	for (j=0; j < ndesc; j++)
	if (j != descindex && desc[j].exact
	&& exact_subkey_match_p (desc+j, node))
	break;
	if (!(j < ndesc))
	skip_until_subkey = 1; /* No other one matching. */
	}
	}

	if (skip_until_subkey)
	continue;

	/* Mark this one as processed. */
	{
	subkey_list_t tmp = new_subkey_list_item (node);
	tmp->next = subkey_list;
	subkey_list = tmp;
	}
	}

	if (node->pkt->pkttype == PKT_SIGNATURE)
	{
	/* Do not export packets which are marked as not
	* exportable. */
	if (!(options & EXPORT_LOCAL_SIGS)
	&& !node->pkt->pkt.signature->flags.exportable)
	continue; /* not exportable */

	/* Do not export packets with a "sensitive" revocation key
	* unless the user wants us to. Note that we do export
	* these when issuing the actual revocation (see revoke.c). */
	if (!(options & EXPORT_SENSITIVE_REVKEYS)
	&& node->pkt->pkt.signature->revkey)
	{
	int i;

	for (i = 0; i < node->pkt->pkt.signature->numrevkeys; i++)
	if ((node->pkt->pkt.signature->revkey[i].class & 0x40))
	break;
	if (i < node->pkt->pkt.signature->numrevkeys)
	continue;
	}
	}

	/* Don't export attribs? */
	if (!(options & EXPORT_ATTRIBUTES)
	&& node->pkt->pkttype == PKT_USER_ID
	&& node->pkt->pkt.user_id->attrib_data)
	{
	/* Skip until we get to something that is not an attrib or a
	* signature on an attrib. */
	while (kbctx->next && kbctx->next->pkt->pkttype == PKT_SIGNATURE)
	kbctx = kbctx->next;

	continue;
	}

	if (secret && (node->pkt->pkttype == PKT_PUBLIC_KEY
	\|\| node->pkt->pkttype == PKT_PUBLIC_SUBKEY))
	{
	pk = node->pkt->pkt.public_key;
	if (node->pkt->pkttype == PKT_PUBLIC_KEY)
	subkid = NULL;
	else
	{
	keyid_from_pk (pk, subkidbuf);
	subkid = subkidbuf;
	}

	if (pk->seckey_info)
	{
	log_error ("key %s: oops: seckey_info already set"
	" - skipped\n", keystr_with_sub (keyid, subkid));
	skip_until_subkey = 1;
	continue;
	}

	xfree (hexgrip);
	err = hexkeygrip_from_pk (pk, &hexgrip);
	if (err)
	{
	log_error ("key %s: error computing keygrip: %s"
	" - skipped\n", keystr_with_sub (keyid, subkid),
	gpg_strerror (err));
	skip_until_subkey = 1;
	err = 0;
	continue;
	}

	xfree (serialno);
	serialno = NULL;
	if (secret == 2 && node->pkt->pkttype == PKT_PUBLIC_KEY)
	{
	/* We are asked not to export the secret parts of the
	* primary key. Make up an error code to create the
	* stub. */
	err = GPG_ERR_NOT_FOUND;
	}
	else
	err = agent_get_keyinfo (ctrl, hexgrip, &serialno, &cleartext);

	if ((!err && serialno)
	&& secret == 2 && node->pkt->pkttype == PKT_PUBLIC_KEY)
	{
	/* It does not make sense to export a key with its
	* primary key on card using a non-key stub. Thus we
	* skip those keys when used with --export-secret-subkeys. */
	log_info (_("key %s: key material on-card - skipped\n"),
	keystr_with_sub (keyid, subkid));
	skip_until_subkey = 1;
	}
	else if (gpg_err_code (err) == GPG_ERR_NOT_FOUND
	\|\| (!err && serialno))
	{
	/* Create a key stub. */
	struct seckey_info *ski;
	const char *s;

	pk->seckey_info = ski = xtrycalloc (1, sizeof *ski);
	if (!ski)
	{
	err = gpg_error_from_syserror ();
	goto leave;
	}

	ski->is_protected = 1;
	if (err)
	ski->s2k.mode = 1001; /* GNU dummy (no secret key). */
	else
	{
	ski->s2k.mode = 1002; /* GNU-divert-to-card. */
	for (s=serialno; sizeof (ski->ivlen) && *s && s[1];
	ski->ivlen++, s += 2)
	ski->iv[ski->ivlen] = xtoi_2 (s);
	}

	err = build_packet (out, node->pkt);
	if (!err && node->pkt->pkttype == PKT_PUBLIC_KEY)
	{
	stats->exported++;
	print_status_exported (node->pkt->pkt.public_key);
	}
	}
	else if (!err)
	{
	err = receive_seckey_from_agent (ctrl, cipherhd,
	cleartext, &cache_nonce,
	hexgrip, pk);
	if (err)
	{
	if (gpg_err_code (err) == GPG_ERR_FULLY_CANCELED)
	goto leave;
	skip_until_subkey = 1;
	err = 0;
	}
	else
	{
	err = build_packet (out, node->pkt);
	if (node->pkt->pkttype == PKT_PUBLIC_KEY)
	{
	stats->exported++;
	print_status_exported (node->pkt->pkt.public_key);
	}
	}
	}
	else
	{
	log_error ("key %s: error getting keyinfo from agent: %s"
	" - skipped\n", keystr_with_sub (keyid, subkid),
	gpg_strerror (err));
	skip_until_subkey = 1;
	err = 0;
	}

	xfree (pk->seckey_info);
	pk->seckey_info = NULL;
	{
	int i;
	for (i = pubkey_get_npkey (pk->pubkey_algo);
	i < pubkey_get_nskey (pk->pubkey_algo); i++)
	{
	gcry_mpi_release (pk->pkey[i]);
	pk->pkey[i] = NULL;
	}
	}
	}
	else /* Not secret or common packets. */
	{
	err = build_packet (out, node->pkt);
	if (!err && node->pkt->pkttype == PKT_PUBLIC_KEY)
	{
	stats->exported++;
	print_status_exported (node->pkt->pkt.public_key);
	}
	}

	if (err)
	{
	log_error ("build_packet(%d) failed: %s\n",
	node->pkt->pkttype, gpg_strerror (err));
	goto leave;
	}

	if (!skip_until_subkey)
	*any = 1;
	}

	leave:
	release_subkey_list (subkey_list);
	xfree (serialno);
	xfree (hexgrip);
	xfree (cache_nonce);
	return err;
	}


	/* Export the keys identified by the list of strings in USERS to the
	stream OUT. If SECRET is false public keys will be exported. With
	secret true secret keys will be exported; in this case 1 means the
	entire secret keyblock and 2 only the subkeys. OPTIONS are the
	export options to apply. If KEYBLOCK_OUT is not NULL, AND the exit
	code is zero, a pointer to the first keyblock found and exported
	will be stored at this address; no other keyblocks are exported in
	this case. The caller must free the returned keyblock. If any
	key has been exported true is stored at ANY. */
	static int
	do_export_stream (ctrl_t ctrl, iobuf_t out, strlist_t users, int secret,
	kbnode_t *keyblock_out, unsigned int options,
	export_stats_t stats, int *any)
	{
	gpg_error_t err = 0;
	PACKET pkt;
	kbnode_t keyblock = NULL;
	kbnode_t node;
	size_t ndesc, descindex;
	KEYDB_SEARCH_DESC *desc = NULL;
	KEYDB_HANDLE kdbhd;
	strlist_t sl;
	gcry_cipher_hd_t cipherhd = NULL;
	struct export_stats_s dummystats;
	iobuf_t out_help = NULL;

	if (!stats)
	stats = &dummystats;
	*any = 0;
	init_packet (&pkt);
	kdbhd = keydb_new ();
	if (!kdbhd)
	return gpg_error_from_syserror ();

	/* For the PKA and DANE format open a helper iobuf and for DANE
	* enforce some options. */
	if ((options & (EXPORT_PKA_FORMAT \| EXPORT_DANE_FORMAT)))
	{
	out_help = iobuf_temp ();
	if ((options & EXPORT_DANE_FORMAT))
	options \|= EXPORT_MINIMAL \| EXPORT_CLEAN;
	}

	if (!users)
	{
	ndesc = 1;
	desc = xcalloc (ndesc, sizeof *desc);
	desc[0].mode = KEYDB_SEARCH_MODE_FIRST;
	}
	else
	{
	for (ndesc=0, sl=users; sl; sl = sl->next, ndesc++)
	;
	desc = xmalloc ( ndesc * sizeof *desc);

	for (ndesc=0, sl=users; sl; sl = sl->next)
	{
	if (!(err=classify_user_id (sl->d, desc+ndesc, 1)))
	ndesc++;
	else
	log_error (_("key \"%s\" not found: %s\n"),
	sl->d, gpg_strerror (err));
	}

	keydb_disable_caching (kdbhd); /* We are looping the search. */

	/* It would be nice to see which of the given users did actually
	match one in the keyring. To implement this we need to have
	a found flag for each entry in desc. To set this flag we
	must check all those entries after a match to mark all
	matched one - currently we stop at the first match. To do
	this we need an extra flag to enable this feature. */
	}

	#ifdef ENABLE_SELINUX_HACKS
	if (secret)
	{
	log_error (_("exporting secret keys not allowed\n"));
	err = gpg_error (GPG_ERR_NOT_SUPPORTED);
	goto leave;
	}
	#endif

	/* For secret key export we need to setup a decryption context. */
	if (secret)
	{
	void *kek = NULL;
	size_t keklen;

	err = agent_keywrap_key (ctrl, 1, &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)
	{
	log_error ("error setting up an encryption context: %s\n",
	gpg_strerror (err));
	goto leave;
	}
	xfree (kek);
	kek = NULL;
	}

	for (;;)
	{
	u32 keyid[2];
	PKT_public_key *pk;

	err = keydb_search (kdbhd, desc, ndesc, &descindex);
	if (!users)
	desc[0].mode = KEYDB_SEARCH_MODE_NEXT;
	if (err)
	break;

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

	node = find_kbnode (keyblock, PKT_PUBLIC_KEY);
	if (!node)
	{
	log_error ("public key packet not found in keyblock - skipped\n");
	continue;
	}
	stats->count++;
	setup_main_keyids (keyblock); /* gpg_format_keydesc needs it. */
	pk = node->pkt->pkt.public_key;
	keyid_from_pk (pk, keyid);

	/* If a secret key export is required we need to check whether
	we have a secret key at all and if so create the seckey_info
	structure. */
	if (secret)
	{
	if (agent_probe_any_secret_key (ctrl, keyblock))
	continue; /* No secret key (neither primary nor subkey). */

	/* No v3 keys with GNU mode 1001. */
	if (secret == 2 && pk->version == 3)
	{
	log_info (_("key %s: PGP 2.x style key - skipped\n"),
	keystr (keyid));
	continue;
	}

	/* The agent does not yet allow to export v3 packets. It is
	actually questionable whether we should allow them at
	all. */
	if (pk->version == 3)
	{
	log_info ("key %s: PGP 2.x style key (v3) export "
	"not yet supported - skipped\n", keystr (keyid));
	continue;
	}
	stats->secret_count++;
	}

	/* Always do the cleaning on the public key part if requested.
	Note that we don't yet set this option if we are exporting
	secret keys. Note that both export-clean and export-minimal
	only apply to UID sigs (0x10, 0x11, 0x12, and 0x13). A
	designated revocation is never stripped, even with
	export-minimal set. */
	if ((options & EXPORT_CLEAN))
	clean_key (keyblock, opt.verbose, (options&EXPORT_MINIMAL), NULL, NULL);

	if (export_keep_uid)
	{
	commit_kbnode (&keyblock);
	apply_keep_uid_filter (keyblock, export_keep_uid);
	commit_kbnode (&keyblock);
	}

	/* And write it. */
	err = do_export_one_keyblock (ctrl, keyblock, keyid,
	out_help? out_help : out,
	secret, options, stats, any,
	desc, ndesc, descindex, cipherhd);
	if (err)
	break;

	if (keyblock_out)
	{
	*keyblock_out = keyblock;
	break;
	}

	if (out_help)
	{
	/* We want to write PKA or DANE records. OUT_HELP has the
	* keyblock and we print a record for each uid to OUT. */
	- char *hexdata;
	const void *data;
	- void *vp;
	size_t datalen;
	- estream_t fp;

	iobuf_flush_temp (out_help);
	data = iobuf_get_temp_buffer (out_help);
	datalen = iobuf_get_temp_length (out_help);
	- hexdata = bin2hex (data, datalen, NULL);
	- if (!hexdata)
	- {
	- err = gpg_error_from_syserror ();
	- goto leave;
	- }
	- iobuf_close (out_help);
	- out_help = iobuf_temp ();
	- ascii_strlwr (hexdata);
	- fp = es_fopenmem (0, "rw,samethread");
	- if (!fp)
	- {
	- err = gpg_error_from_syserror ();
	- xfree (hexdata);
	- goto leave;
	- }

	- {
	- char *hexfpr = hexfingerprint (pk, NULL, 0);
	- err = print_pka_or_dane_records (keyblock, hexdata, hexfpr, fp,
	- (options & EXPORT_PKA_FORMAT),
	- (options & EXPORT_DANE_FORMAT));
	- xfree (hexfpr);
	- }
	- xfree (hexdata);
	+ err = print_pka_or_dane_records (out,
	+ keyblock, pk, data, datalen,
	+ (options & EXPORT_PKA_FORMAT),
	+ (options & EXPORT_DANE_FORMAT));
	if (err)
	- {
	- es_fclose (fp);
	- goto leave;
	- }
	- es_fputc (0, fp);
	- if (es_fclose_snatch (fp, &vp, NULL))
	- {
	- err = gpg_error_from_syserror ();
	- goto leave;
	- }
	- iobuf_writestr (out, vp);
	+ goto leave;
	+
	+ iobuf_close (out_help);
	+ out_help = iobuf_temp ();
	}

	}
	if (gpg_err_code (err) == GPG_ERR_NOT_FOUND)
	err = 0;

	leave:
	iobuf_cancel (out_help);
	gcry_cipher_close (cipherhd);
	xfree(desc);
	keydb_release (kdbhd);
	if (err \|\| !keyblock_out)
	release_kbnode( keyblock );
	if( !*any )
	log_info(_("WARNING: nothing exported\n"));
	return err;
	}




	static gpg_error_t
	key_to_sshblob (membuf_t mb, const char identifier, ...)
	{
	va_list arg_ptr;
	gpg_error_t err = 0;
	unsigned char nbuf[4];
	unsigned char *buf;
	size_t buflen;
	gcry_mpi_t a;

	ulongtobuf (nbuf, (ulong)strlen (identifier));
	put_membuf (mb, nbuf, 4);
	put_membuf_str (mb, identifier);
	if (!strncmp (identifier, "ecdsa-sha2-", 11))
	{
	ulongtobuf (nbuf, (ulong)strlen (identifier+11));
	put_membuf (mb, nbuf, 4);
	put_membuf_str (mb, identifier+11);
	}
	va_start (arg_ptr, identifier);
	while ((a = va_arg (arg_ptr, gcry_mpi_t)))
	{
	err = gcry_mpi_aprint (GCRYMPI_FMT_SSH, &buf, &buflen, a);
	if (err)
	break;
	if (!strcmp (identifier, "ssh-ed25519")
	&& buflen > 5 && buf[4] == 0x40)
	{
	/* We need to strip our 0x40 prefix. */
	put_membuf (mb, "\x00\x00\x00\x20", 4);
	put_membuf (mb, buf+5, buflen-5);
	}
	else
	put_membuf (mb, buf, buflen);
	gcry_free (buf);
	}
	va_end (arg_ptr);
	return err;
	}

	/* Export the key identified by USERID in the SSH public key format.
	The function exports the latest subkey with Authentication
	capability unless the '!' suffix is used to export a specific
	key. */
	gpg_error_t
	export_ssh_key (ctrl_t ctrl, const char *userid)
	{
	gpg_error_t err;
	kbnode_t keyblock = NULL;
	KEYDB_SEARCH_DESC desc;
	u32 latest_date;
	u32 curtime = make_timestamp ();
	kbnode_t latest_key, node;
	PKT_public_key *pk;
	const char *identifier;
	membuf_t mb;
	estream_t fp = NULL;
	struct b64state b64_state;
	const char *fname = "-";

	init_membuf (&mb, 4096);

	/* We need to know whether the key has been specified using the
	exact syntax ('!' suffix). Thus we need to run a
	classify_user_id on our own. */
	err = classify_user_id (userid, &desc, 1);

	/* Get the public key. */
	if (!err)
	{
	getkey_ctx_t getkeyctx;

	err = get_pubkey_byname (ctrl, &getkeyctx, NULL, userid, &keyblock,
	NULL,
	0 /* Only usable keys or given exact. */,
	1 /* No AKL lookup. */);
	if (!err)
	{
	err = getkey_next (getkeyctx, NULL, NULL);
	if (!err)
	err = gpg_error (GPG_ERR_AMBIGUOUS_NAME);
	else if (gpg_err_code (err) == GPG_ERR_NO_PUBKEY)
	err = 0;
	}
	getkey_end (getkeyctx);
	}
	if (err)
	{
	log_error (_("key \"%s\" not found: %s\n"), userid, gpg_strerror (err));
	return err;
	}

	/* The finish_lookup code in getkey.c does not handle auth keys,
	thus we have to duplicate the code here to find the latest
	subkey. However, if the key has been found using an exact match
	('!' notation) we use that key without any further checks and
	even allow the use of the primary key. */
	latest_date = 0;
	latest_key = NULL;
	for (node = keyblock; node; node = node->next)
	{
	if ((node->pkt->pkttype == PKT_PUBLIC_SUBKEY
	\|\| node->pkt->pkttype == PKT_PUBLIC_KEY)
	&& node->pkt->pkt.public_key->flags.exact)
	{
	latest_key = node;
	break;
	}
	}
	if (!latest_key)
	{
	for (node = keyblock; node; node = node->next)
	{
	if (node->pkt->pkttype != PKT_PUBLIC_SUBKEY)
	continue;

	pk = node->pkt->pkt.public_key;
	if (DBG_LOOKUP)
	log_debug ("\tchecking subkey %08lX\n",
	(ulong) keyid_from_pk (pk, NULL));
	if (!(pk->pubkey_usage & PUBKEY_USAGE_AUTH))
	{
	if (DBG_LOOKUP)
	log_debug ("\tsubkey not usable for authentication\n");
	continue;
	}
	if (!pk->flags.valid)
	{
	if (DBG_LOOKUP)
	log_debug ("\tsubkey not valid\n");
	continue;
	}
	if (pk->flags.revoked)
	{
	if (DBG_LOOKUP)
	log_debug ("\tsubkey has been revoked\n");
	continue;
	}
	if (pk->has_expired)
	{
	if (DBG_LOOKUP)
	log_debug ("\tsubkey has expired\n");
	continue;
	}
	if (pk->timestamp > curtime && !opt.ignore_valid_from)
	{
	if (DBG_LOOKUP)
	log_debug ("\tsubkey not yet valid\n");
	continue;
	}
	if (DBG_LOOKUP)
	log_debug ("\tsubkey might be fine\n");
	/* In case a key has a timestamp of 0 set, we make sure that it
	is used. A better change would be to compare ">=" but that
	might also change the selected keys and is as such a more
	intrusive change. */
	if (pk->timestamp > latest_date \|\| (!pk->timestamp && !latest_date))
	{
	latest_date = pk->timestamp;
	latest_key = node;
	}
	}
	}

	if (!latest_key)
	{
	err = gpg_error (GPG_ERR_UNUSABLE_PUBKEY);
	log_error (_("key \"%s\" not found: %s\n"), userid, gpg_strerror (err));
	goto leave;
	}

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

	switch (pk->pubkey_algo)
	{
	case PUBKEY_ALGO_DSA:
	identifier = "ssh-dss";
	err = key_to_sshblob (&mb, identifier,
	pk->pkey[0], pk->pkey[1], pk->pkey[2], pk->pkey[3],
	NULL);
	break;

	case PUBKEY_ALGO_RSA:
	case PUBKEY_ALGO_RSA_S:
	identifier = "ssh-rsa";
	err = key_to_sshblob (&mb, identifier, pk->pkey[1], pk->pkey[0], NULL);
	break;

	case PUBKEY_ALGO_ECDSA:
	{
	char *curveoid;
	const char *curve;

	curveoid = openpgp_oid_to_str (pk->pkey[0]);
	if (!curveoid)
	err = gpg_error_from_syserror ();
	else if (!(curve = openpgp_oid_to_curve (curveoid, 0)))
	err = gpg_error (GPG_ERR_UNKNOWN_CURVE);
	else
	{
	if (!strcmp (curve, "nistp256"))
	identifier = "ecdsa-sha2-nistp256";
	else if (!strcmp (curve, "nistp384"))
	identifier = "ecdsa-sha2-nistp384";
	else if (!strcmp (curve, "nistp521"))
	identifier = "ecdsa-sha2-nistp521";
	else
	identifier = NULL;

	if (!identifier)
	err = gpg_error (GPG_ERR_UNKNOWN_CURVE);
	else
	err = key_to_sshblob (&mb, identifier, pk->pkey[1], NULL);
	}
	xfree (curveoid);
	}
	break;

	case PUBKEY_ALGO_EDDSA:
	if (!openpgp_oid_is_ed25519 (pk->pkey[0]))
	err = gpg_error (GPG_ERR_UNKNOWN_CURVE);
	else
	{
	identifier = "ssh-ed25519";
	err = key_to_sshblob (&mb, identifier, pk->pkey[1], NULL);
	}
	break;

	case PUBKEY_ALGO_ELGAMAL_E:
	case PUBKEY_ALGO_ELGAMAL:
	err = gpg_error (GPG_ERR_UNUSABLE_PUBKEY);
	break;

	default:
	err = GPG_ERR_PUBKEY_ALGO;
	break;
	}

	if (err)
	goto leave;

	if (opt.outfile && *opt.outfile && strcmp (opt.outfile, "-"))
	fp = es_fopen ((fname = opt.outfile), "w");
	else
	fp = es_stdout;
	if (!fp)
	{
	err = gpg_error_from_syserror ();
	log_error (_("error creating '%s': %s\n"), fname, gpg_strerror (err));
	goto leave;
	}

	es_fprintf (fp, "%s ", identifier);
	err = b64enc_start_es (&b64_state, fp, "");
	if (err)
	goto leave;
	{
	void *blob;
	size_t bloblen;

	blob = get_membuf (&mb, &bloblen);
	if (!blob)
	err = gpg_error_from_syserror ();
	else
	err = b64enc_write (&b64_state, blob, bloblen);
	xfree (blob);
	if (err)
	goto leave;
	}
	err = b64enc_finish (&b64_state);
	if (err)
	goto leave;
	es_fprintf (fp, " openpgp:0x%08lX\n", (ulong)keyid_from_pk (pk, NULL));

	if (es_ferror (fp))
	err = gpg_error_from_syserror ();
	else
	{
	if (es_fclose (fp))
	err = gpg_error_from_syserror ();
	fp = NULL;
	}

	if (err)
	log_error (_("error writing '%s': %s\n"), fname, gpg_strerror (err));

	leave:
	es_fclose (fp);
	xfree (get_membuf (&mb, NULL));
	release_kbnode (keyblock);
	return err;
	}
	diff --git a/g10/import.c b/g10/import.c
	index 371f0951a..375bd03f8 100644
	--- a/g10/import.c
	+++ b/g10/import.c
	@@ -1,3171 +1,3171 @@
	/* import.c - import a key into our key storage.
	* Copyright (C) 1998-2007, 2010-2011 Free Software Foundation, Inc.
	* Copyright (C) 2014, 2016 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 "gpg.h"
	#include "options.h"
	#include "packet.h"
	#include "status.h"
	#include "keydb.h"
	#include "util.h"
	#include "trustdb.h"
	#include "main.h"
	#include "i18n.h"
	#include "ttyio.h"
	#include "status.h"
	#include "recsel.h"
	#include "keyserver-internal.h"
	#include "call-agent.h"
	#include "../common/membuf.h"
	#include "../common/init.h"
	#include "../common/mbox-util.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 global variable to store the selector created from
	* --import-filter keep-uid=EXPR.
	*
	* FIXME: We should put this into the CTRL object but that requires a
	* lot more changes right now.
	*/
	static recsel_expr_t import_keep_uid;



	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);
	static int read_block (IOBUF a, PACKET *pending_pkt, kbnode_t ret_root,
	int *r_v3keys);
	static void revocation_present (ctrl_t ctrl, kbnode_t keyblock);
	static int 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);
	static int 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);
	static int import_revoke_cert (kbnode_t node, struct import_stats_s *stats);
	static int chk_self_sigs (kbnode_t keyblock, u32 keyid, int non_self);
	static int delete_inv_parts (kbnode_t keyblock,
	u32 *keyid, unsigned int options);
	static int merge_blocks (kbnode_t keyblock_orig,
	kbnode_t keyblock, u32 *keyid,
	int n_uids, int n_sigs, int *n_subk );
	static int append_uid (kbnode_t keyblock, kbnode_t node, 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
	cleanup_import_globals (void)
	{
	recsel_release (import_keep_uid);
	import_keep_uid = NULL;
	}


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

	{"import-show",IMPORT_SHOW,NULL,
	N_("show key during 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")},

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

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

	return parse_options(str,options,import_opts,noisy);
	}


	/* 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_keep_uid, string+9);
	else
	err = gpg_error (GPG_ERR_INV_NAME);

	return err;
	}



	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 (ctrl_t ctrl, const char fname, 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;

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

	/* Read the first non-v3 keyblock. */
	while (!(err = read_block (inp, &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"),
	iobuf_is_pipe_filename (fname)? "[stdin]": fname,
	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;
	}

	collapse_uids (&keyblock);

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

	if (!delete_inv_parts (keyblock, keyid, 0) )
	{
	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. */
	iobuf_ioctl (NULL, IOBUF_IOCTL_INVALIDATE_CACHE, 0, (char*)fname);
	}
	release_kbnode (keyblock);
	/* FIXME: Do we need to free PENDING_PKT ? */
	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 int
	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 i;
	int rc = 0;
	struct import_stats_s *stats = stats_handle;

	if (!stats)
	stats = import_new_stats_handle ();

	if (inp)
	{
	rc = import (ctrl, inp, "[stream]", stats, fpr, fpr_len, options,
	screener, screener_arg);
	}
	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
	{
	rc = import (ctrl, inp2, fname, stats, fpr, fpr_len, options,
	screener, screener_arg);
	iobuf_close (inp2);
	/* Must invalidate that ugly cache to actually close it. */
	iobuf_ioctl (NULL, IOBUF_IOCTL_INVALIDATE_CACHE, 0, (char*)fname);
	if (rc)
	log_error ("import from '%s' failed: %s\n",
	fname, gpg_strerror (rc) );
	}
	if (!fname)
	break;
	}
	}

	if (!stats_handle)
	{
	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 rc;
	}


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

	int
	import_keys_stream (ctrl_t ctrl, IOBUF inp, import_stats_t stats_handle,
	unsigned char *fpr, size_t fpr_len, unsigned int options)
	{
	return import_keys_internal (ctrl, inp, NULL, 0, stats_handle,
	fpr, fpr_len, options, NULL, NULL);
	}


	/* Variant of import_keys_stream reading from an estream_t. */
	int
	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 rc;
	iobuf_t inp;

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

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

	iobuf_close (inp);
	return rc;
	}


	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)
	{
	PACKET *pending_pkt = NULL;
	kbnode_t keyblock = NULL; /* Need to initialize because gcc can't
	grasp the return semantics of
	read_block. */
	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, &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);
	else if (keyblock->pkt->pkttype == PKT_SECRET_KEY)
	rc = import_secret_one (ctrl, keyblock, stats,
	opt.batch, options, 0,
	screener, screener_arg);
	else if (keyblock->pkt->pkttype == PKT_SIGNATURE
	&& keyblock->pkt->pkt.signature->sig_class == 0x20 )
	rc = import_revoke_cert (keyblock, stats);
	else
	{
	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 );
	}
	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));

	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, &pending_pkt, &keyblock, &v3keys)))
	{
	if (keyblock->pkt->pkttype == PKT_SECRET_KEY)
	err = import_secret_one (ctrl, keyblock, stats, 1, 0, 1,
	NULL, NULL);
	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.
	* PENDING_PKT should be initialzed to NULL
	* and not changed by the caller.
	* Return: 0 = okay, -1 no more blocks or another errorcode.
	* The int at at R_V3KEY counts the number of unsupported v3
	* keyblocks.
	*/
	static int
	read_block( IOBUF a, PACKET *pending_pkt, kbnode_t ret_root, int *r_v3keys)
	{
	int rc;
	PACKET *pkt;
	kbnode_t root = NULL;
	int in_cert, in_v3key;

	*r_v3keys = 0;

	if (*pending_pkt)
	{
	root = new_kbnode( *pending_pkt );
	*pending_pkt = NULL;
	in_cert = 1;
	}
	else
	in_cert = 0;

	pkt = xmalloc (sizeof *pkt);
	init_packet (pkt);
	in_v3key = 0;
	while ((rc=parse_packet(a, 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);
	init_packet (pkt);
	continue;
	}
	else if (rc ) /* (ignore errors) */
	{
	if (gpg_err_code (rc) == GPG_ERR_UNKNOWN_PACKET)
	; /* Do not show a diagnostic. */
	else
	{
	log_error("read_block: read error: %s\n", gpg_strerror (rc) );
	rc = GPG_ERR_INV_KEYRING;
	goto ready;
	}
	free_packet( pkt );
	init_packet(pkt);
	continue;
	}

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

	if (!root && pkt->pkttype == PKT_SIGNATURE
	&& pkt->pkt.signature->sig_class == 0x20 )
	{
	/* 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 (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;
	push_compress_filter2(a,cfx,pkt->pkt.compressed->algorithm,1);
	}
	free_packet( pkt );
	init_packet(pkt);
	break;

	case PKT_RING_TRUST:
	/* Skip those packets. */
	free_packet( pkt );
	init_packet(pkt);
	break;

	case PKT_PUBLIC_KEY:
	case PKT_SECRET_KEY:
	if (in_cert ) /* Store this packet. */
	{
	*pending_pkt = pkt;
	pkt = NULL;
	goto ready;
	}
	in_cert = 1;
	default:
	if (in_cert && valid_keyblock_packet (pkt->pkttype))
	{
	if (!root )
	root = new_kbnode (pkt);
	else
	add_kbnode (root, new_kbnode (pkt));
	pkt = xmalloc (sizeof *pkt);
	}
	init_packet(pkt);
	break;
	}
	}

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

	if (rc )
	release_kbnode( root );
	else
	*ret_root = root;
	free_packet( pkt );
	xfree( pkt );
	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 (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
	&& node->pkt->pkt.signature->sig_class == 0x18
	&& 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 (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 (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 (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)
	{
	char * buf;
	byte fpr[24];
	u32 keyid[2];
	size_t i, n;
	size_t pos = 0;

	buf = xmalloc (17+41+id->len+32);
	keyid_from_pk (pk, keyid);
	sprintf (buf, "%08X%08X ", keyid[0], keyid[1]);
	pos = 17;
	fingerprint_from_pk (pk, fpr, &n);
	for (i = 0; i < n; i++, pos += 2)
	sprintf (buf+pos, "%02X", fpr[i]);
	strcat (buf, " ");
	strcat (buf, id->name);
	write_status_text (STATUS_IMPORT_CHECK, buf);
	xfree (buf);
	}


	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(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_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_keep_uid_filter. */
	static const char *
	filter_getval (void cookie, const char propname)
	{
	kbnode_t node = cookie;
	const char *result;

	if (node->pkt->pkttype == PKT_USER_ID)
	{
	if (!strcmp (propname, "uid"))
	result = node->pkt->pkt.user_id->name;
	else if (!strcmp (propname, "mbox"))
	{
	if (!node->pkt->pkt.user_id->mbox)
	{
	node->pkt->pkt.user_id->mbox
	= mailbox_from_userid (node->pkt->pkt.user_id->name);
	}
	return node->pkt->pkt.user_id->mbox;
	}
	else if (!strcmp (propname, "primary"))
	result = node->pkt->pkt.user_id->is_primary? "1":"0";
	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 (kbnode_t keyblock, recsel_expr_t selector)
	{
	kbnode_t node;

	for (node = keyblock->next; node; node = node->next )
	{
	if (node->pkt->pkttype == PKT_USER_ID)
	{
	if (!recsel_select (selector, filter_getval, node))
	{

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


	/*
	* 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.
	*/
	static int
	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)
	{
	PKT_public_key *pk;
	PKT_public_key *pk_orig = NULL;
	kbnode_t node, uidnode;
	kbnode_t keyblock_orig = NULL;
	byte fpr2[MAX_FINGERPRINT_LEN];
	size_t fpr2len;
	u32 keyid[2];
	int rc = 0;
	int new_key = 0;
	int mod_key = 0;
	int same_key = 0;
	int non_self = 0;
	size_t an;
	char pkstrbuf[PUBKEY_STRING_SIZE];
	int merge_keys_done = 0;

	/* 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);
	for (an = fpr2len; an < MAX_FINGERPRINT_LEN; an++)
	fpr2[an] = 0;
	keyid_from_pk( pk, keyid );
	uidnode = find_next_kbnode( keyblock, PKT_USER_ID );

	if (opt.verbose && !opt.interactive && !silent)
	{
	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 (keyblock);
	tty_printf ("\n");
	show_basic_key_info (keyblock);
	tty_printf ("\n");
	if (!cpr_get_answer_is_yes ("import.okay",
	"Do you want to import this key? (y/N) "))
	return 0;
	}

	collapse_uids(&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)
	clean_key (keyblock,opt.verbose,options&IMPORT_MINIMAL,NULL,NULL);

	clear_kbnode_flags( keyblock );

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

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

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

	if (!delete_inv_parts (keyblock, keyid, options ) )
	{
	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_keep_uid)
	{
	apply_keep_uid_filter (keyblock, import_keep_uid);
	commit_kbnode (&keyblock);
	}


	/* 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 (keyblock);
	merge_keys_done = 1;
	/* Note that we do not want to show the validity because the key
	* has not yet imported. */
	list_keyblock_direct (ctrl, keyblock, 0, 0, 1, 1);
	es_fflush (es_stdout);
	}

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

	if (opt.dry_run)
	goto leave;

	/* Do we have this key already in one of our pubrings ? */
	pk_orig = xmalloc_clear( sizeof *pk_orig );
	rc = get_pubkey_byfprint_fast (pk_orig, fpr2, fpr2len);
	if (rc && gpg_err_code (rc) != GPG_ERR_NO_PUBKEY
	&& gpg_err_code (rc) != GPG_ERR_UNUSABLE_PUBKEY )
	{
	if (!silent)
	log_error (_("key %s: public key not found: %s\n"),
	keystr(keyid), gpg_strerror (rc));
	}
	else if ( rc && (opt.import_options&IMPORT_MERGE_ONLY) )
	{
	if (opt.verbose && !silent )
	log_info( _("key %s: new key - skipped\n"), keystr(keyid));
	rc = 0;
	stats->skipped_new_keys++;
	}
	else if (rc ) /* Insert this key. */
	{
	KEYDB_HANDLE hd;

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

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

	rc = keydb_insert_keyblock (hd, keyblock );
	if (rc)
	log_error (_("error writing keyring '%s': %s\n"),
	keydb_get_resource_name (hd), gpg_strerror (rc));
	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 (pk);
	if (non_self)
	revalidation_mark ();
	}
	keydb_release (hd);

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

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

	/* Now read the original keyblock again so that we can use
	that handle for updating the keyblock. */
	hd = keydb_new ();
	if (!hd)
	{
	rc = gpg_error_from_syserror ();
	goto leave;
	}
	keydb_disable_caching (hd);
	rc = keydb_search_fpr (hd, fpr2);
	if (rc )
	{
	log_error (_("key %s: can't locate original keyblock: %s\n"),
	keystr(keyid), gpg_strerror (rc));
	keydb_release (hd);
	goto leave;
	}
	rc = keydb_get_keyblock (hd, &keyblock_orig);
	if (rc)
	{
	log_error (_("key %s: can't read original keyblock: %s\n"),
	keystr(keyid), gpg_strerror (rc));
	keydb_release (hd);
	goto leave;
	}

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

	/* and try to merge the block */
	clear_kbnode_flags( keyblock_orig );
	clear_kbnode_flags( keyblock );
	n_uids = n_sigs = n_subk = n_uids_cleaned = 0;
	rc = merge_blocks (keyblock_orig, keyblock,
	keyid, &n_uids, &n_sigs, &n_subk );
	if (rc )
	{
	keydb_release (hd);
	goto leave;
	}

	if ((options & IMPORT_CLEAN))
	clean_key (keyblock_orig,opt.verbose,options&IMPORT_MINIMAL,
	&n_uids_cleaned,&n_sigs_cleaned);

	if (n_uids \|\| n_sigs \|\| n_subk \|\| n_sigs_cleaned \|\| n_uids_cleaned)
	{
	mod_key = 1;
	/* KEYBLOCK_ORIG has been updated; write */
	rc = keydb_update_keyblock (hd, keyblock_orig);
	if (rc)
	log_error (_("error writing keyring '%s': %s\n"),
	keydb_get_resource_name (hd), gpg_strerror (rc) );
	else if (non_self)
	revalidation_mark ();

	/* We are ready. */
	if (!opt.quiet && !silent)
	{
	char *p = get_user_id_byfpr_native (fpr2);
	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);
	}

	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
	{
	same_key = 1;
	if (is_status_enabled ())
	print_import_ok (pk, 0);

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

	stats->unchanged++;
	}

	keydb_release (hd); hd = NULL;
	}

	leave:
	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)
	{
	xfree (*fpr);
	/* Note that we need to compare against 0 here because
	COUNT gets only incremented after returning from this
	function. */
	if (!stats->count)
	*fpr = fingerprint_from_pk (pk, NULL, fpr_len);
	else
	*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 (keyid))
	check_prefs (ctrl, keyblock_orig);
	}
	else if (new_key)
	{
	revocation_present (ctrl, keyblock);
	if (!from_sk && have_secret_key_with_kid (keyid))
	check_prefs (ctrl, keyblock);
	}

	release_kbnode( keyblock_orig );
	free_public_key( pk_orig );

	return rc;
	}


	/* 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). */
	gpg_error_t
	transfer_secret_keys (ctrl_t ctrl, struct import_stats_s *stats,
	kbnode_t sec_keyblock, int batch, int force)
	{
	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;

	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;
	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);
	xfree (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;
	}
	}
	}
	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];

	/* 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 (pk, FORMAT_KEYDESC_IMPORT, 1);
	err = agent_import_key (ctrl, desc, &cache_nonce,
	wrappedkey, wrappedkeylen, batch, force);
	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. */
	static kbnode_t
	sec_to_pub_keyblock (kbnode_t sec_keyblock)
	{
	kbnode_t pub_keyblock = NULL;
	kbnode_t ctx = NULL;
	kbnode_t secnode, pubnode;

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

	if (!pub_keyblock)
	pub_keyblock = pubnode;
	else
	add_kbnode (pub_keyblock, pubnode);
	}

	return pub_keyblock;
	}

	/****************
	* Ditto for secret keys. 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.
	*/
	static int
	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)
	{
	PKT_public_key *pk;
	struct seckey_info *ski;
	kbnode_t node, uidnode;
	u32 keyid[2];
	int rc = 0;
	int nr_prev;
	kbnode_t pub_keyblock;
	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;

	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"));
	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_NO_SECKEY))
	{
	if (!for_migration)
	log_error (_("importing secret keys not allowed\n"));
	return 0;
	}

	if (!uidnode)
	{
	if (!for_migration)
	log_error( _("key %s: no user ID\n"), keystr_from_pk (pk));
	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));
	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);
	return 0;
	}

	#ifdef ENABLE_SELINUX_HACKS
	if (1)
	{
	/* We don't allow to import 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"));
	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)
	log_error ("key %s: failed to create public key from secret key\n",
	keystr_from_pk (pk));
	else
	{
	/* 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);

	/* Fixme: We should check for an invalid keyblock and
	cancel the secret key import in this case. */
	release_kbnode (pub_keyblock);

	/* 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 (stats->skipped_new_keys <= nr_prev)
	{
	/* Read the keyblock again to get the effects of a merge. */
	/* Fixme: we should do this based on the fingerprint or
	even better let import_one return the merged
	keyblock. */
	node = get_pubkeyblock (keyid);
	if (!node)
	log_error ("key %s: failed to re-lookup public key\n",
	keystr_from_pk (pk));
	else
	{
	gpg_error_t err;

	nr_prev = stats->secret_imported;
	err = transfer_secret_keys (ctrl, stats, keyblock, batch, 0);
	if (gpg_err_code (err) == GPG_ERR_NOT_PROCESSED)
	{
	/* TRANSLATORS: For 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 (stats->secret_imported > nr_prev)
	status \|= 1;
	if (is_status_enabled ())
	print_import_ok (pk, status);
	check_prefs (ctrl, node);
	}
	release_kbnode (node);
	}
	}
	}

	return rc;
	}


	/****************
	* Import a revocation certificate; this is a single signature packet.
	*/
	static int
	import_revoke_cert (kbnode_t node, 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;

	log_assert (!node->next );
	log_assert (node->pkt->pkttype == PKT_SIGNATURE );
	log_assert (node->pkt->pkt.signature->sig_class == 0x20 );

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

	pk = xmalloc_clear( sizeof *pk );
	rc = get_pubkey( pk, keyid );
	if (gpg_err_code (rc) == GPG_ERR_NO_PUBKEY )
	{
	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 ();
	if (!hd)
	{
	rc = gpg_error_from_syserror ();
	goto leave;
	}

	{
	byte afp[MAX_FINGERPRINT_LEN];
	size_t an;

	fingerprint_from_pk (pk, afp, &an);
	while (an < MAX_FINGERPRINT_LEN)
	afp[an++] = 0;
	rc = keydb_search_fpr (hd, afp);
	}
	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 in this
	* special case. */
	rc = check_key_signature( keyblock, node, NULL);
	if (rc )
	{
	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 */
	rc = keydb_update_keyblock (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 (keyid);
	log_info( _("key %s: \"%s\" revocation certificate imported\n"),
	keystr(keyid),p);
	xfree(p);
	}
	stats->n_revoc++;

	/* 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(pk)==TRUST_ULTIMATE)
	clear_ownertrusts(pk);

	revalidation_mark ();

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


	/* Loop over the keyblock and check all self signatures. On return
	* the following bis 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 (kbnode_t keyblock, u32 keyid, int non_self )
	{
	kbnode_t n, knode = NULL;
	PKT_signature *sig;
	int rc;
	u32 bsdate=0, rsdate=0;
	kbnode_t bsnode = NULL, rsnode = NULL;

	for (n=keyblock; (n = find_next_kbnode (n, 0)); )
	{
	if (n->pkt->pkttype == PKT_PUBLIC_SUBKEY)
	{
	knode = n;
	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 (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 (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 (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 (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 binding\n"),
	keystr (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)
	log_info (_("key %s: removed multiple subkey"
	" binding\n"),keystr(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 (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 implemenation; but
	* consider RSA as valid, because parse/build_packets knows about it.
	*
	* Returns: True if at least one valid user-id is left over.
	*/
	static int
	delete_inv_parts (kbnode_t keyblock, u32 *keyid, unsigned int options)
	{
	kbnode_t node;
	int nvalid=0, uid_seen=0, subkey_seen=0;

	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 )
	log_info( _("key %s: skipped subkey\n"),keystr(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 (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
	&& node->pkt->pkt.signature->sig_class == 0x20)
	{
	if (uid_seen )
	{
	if(opt.verbose)
	log_info( _("key %s: revocation certificate"
	" at wrong place - skipped\n"),keystr(keyid));
	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( 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 (node->pkt->pkttype == PKT_SIGNATURE
	&& (node->pkt->pkt.signature->sig_class == 0x18
	\|\| node->pkt->pkt.signature->sig_class == 0x28)
	&& !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;
	}


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


	/* 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 &&
	onode->pkt->pkt.signature->sig_class==0x1F &&
	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(sig->revkey[idx].fpr,
	MAX_FINGERPRINT_LEN,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 &&
	inode->pkt->pkt.signature->sig_class==0x20 &&
	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? */
	int rc;

	rc=get_pubkey_byfprint_fast (NULL,sig->revkey[idx].fpr,
	MAX_FINGERPRINT_LEN);
	if (gpg_err_code (rc) == GPG_ERR_NO_PUBKEY
	\|\| gpg_err_code (rc) == 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_fprint (ctrl,
	sig->revkey[idx].fpr,
	MAX_FINGERPRINT_LEN,
	opt.keyserver);

	/* Do we have it now? */
	rc=get_pubkey_byfprint_fast (NULL,
	sig->revkey[idx].fpr,
	MAX_FINGERPRINT_LEN);
	}

	if (gpg_err_code (rc) == GPG_ERR_NO_PUBKEY
	\|\| gpg_err_code (rc) == 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 (kbnode_t keyblock_orig, kbnode_t keyblock,
	u32 keyid, 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
	&& node->pkt->pkt.signature->sig_class == 0x20)
	{
	/* 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
	&& onode->pkt->pkt.signature->sig_class == 0x20
	&& !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 (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
	&& node->pkt->pkt.signature->sig_class == 0x1F)
	{
	/* 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
	&& onode->pkt->pkt.signature->sig_class == 0x1F
	&& !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_uid (keyblock_orig, node, 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 userid starting with NODE and all signatures to KEYBLOCK.
	*/
	static int
	append_uid (kbnode_t keyblock, kbnode_t node, int *n_sigs)
	{
	kbnode_t n;
	kbnode_t n_where = NULL;

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

	/* find the position */
	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_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 (n->pkt->pkt.signature->sig_class == 0x18
	\|\| n->pkt->pkt.signature->sig_class == 0x28 )
	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/main.h b/g10/main.h
	index 92a26a7ed..0956f6693 100644
	--- a/g10/main.h
	+++ b/g10/main.h
	@@ -1,480 +1,481 @@
	/* main.h
	* Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
	* 2008, 2009, 2010 Free Software Foundation, Inc.
	*
	* This file is part of GnuPG.
	*
	* GnuPG is free software; you can redistribute it and/or modify
	* it under the terms of the GNU General Public License as published by
	* the Free Software Foundation; either version 3 of the License, or
	* (at your option) any later version.
	*
	* GnuPG is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with this program; if not, see <http://www.gnu.org/licenses/>.
	*/
	#ifndef G10_MAIN_H
	#define G10_MAIN_H

	#include "types.h"
	#include "iobuf.h"
	#include "keydb.h"
	#include "util.h"

	/* It could be argued that the default cipher should be 3DES rather
	than AES128, and the default compression should be 0
	(i.e. uncompressed) rather than 1 (zip). However, the real world
	issues of speed and size come into play here. */

	#if GPG_USE_AES128
	# define DEFAULT_CIPHER_ALGO CIPHER_ALGO_AES
	#elif GPG_USE_CAST5
	# define DEFAULT_CIPHER_ALGO CIPHER_ALGO_CAST5
	#else
	# define DEFAULT_CIPHER_ALGO CIPHER_ALGO_3DES
	#endif

	#define DEFAULT_DIGEST_ALGO ((GNUPG)? DIGEST_ALGO_SHA256:DIGEST_ALGO_SHA1)
	#define DEFAULT_S2K_DIGEST_ALGO DIGEST_ALGO_SHA1
	#ifdef HAVE_ZIP
	# define DEFAULT_COMPRESS_ALGO COMPRESS_ALGO_ZIP
	#else
	# define DEFAULT_COMPRESS_ALGO COMPRESS_ALGO_NONE
	#endif


	#define S2K_DIGEST_ALGO (opt.s2k_digest_algo?opt.s2k_digest_algo:DEFAULT_S2K_DIGEST_ALGO)


	/* Various data objects. */

	typedef struct
	{
	int header_okay;
	PK_LIST pk_list;
	DEK *symkey_dek;
	STRING2KEY *symkey_s2k;
	cipher_filter_context_t cfx;
	} encrypt_filter_context_t;


	struct groupitem
	{
	char *name;
	strlist_t values;
	struct groupitem *next;
	};

	struct weakhash
	{
	enum gcry_md_algos algo;
	int rejection_shown;
	struct weakhash *next;
	};


	/-- gpg.c --/
	extern int g10_errors_seen;

	#if __GNUC__ > 2 \|\| (__GNUC__ == 2 && __GNUC_MINOR__ >= 5 )
	void g10_exit(int rc) __attribute__ ((noreturn));
	#else
	void g10_exit(int rc);
	#endif
	void print_pubkey_algo_note (pubkey_algo_t algo);
	void print_cipher_algo_note (cipher_algo_t algo);
	void print_digest_algo_note (digest_algo_t algo);
	void print_digest_rejected_note (enum gcry_md_algos algo);
	void print_reported_error (gpg_error_t err, gpg_err_code_t skip_if_ec);
	void print_further_info (const char *format, ...) GPGRT_ATTR_PRINTF(1,2);
	void additional_weak_digest (const char* digestname);

	/-- armor.c --/
	char make_radix64_string( const byte data, size_t len );

	/-- misc.c --/
	void trap_unaligned(void);
	void register_secured_file (const char *fname);
	void unregister_secured_file (const char *fname);
	int is_secured_file (int fd);
	int is_secured_filename (const char *fname);
	u16 checksum_u16( unsigned n );
	u16 checksum( byte *p, unsigned n );
	u16 checksum_mpi( gcry_mpi_t a );
	u32 buffer_to_u32( const byte *buffer );
	const byte get_session_marker( size_t rlen );

	enum gcry_cipher_algos map_cipher_openpgp_to_gcry (cipher_algo_t algo);
	#define openpgp_cipher_open(_a,_b,_c,_d) \
	gcry_cipher_open((_a),map_cipher_openpgp_to_gcry((_b)),(_c),(_d))
	#define openpgp_cipher_get_algo_keylen(_a) \
	gcry_cipher_get_algo_keylen(map_cipher_openpgp_to_gcry((_a)))
	#define openpgp_cipher_get_algo_blklen(_a) \
	gcry_cipher_get_algo_blklen(map_cipher_openpgp_to_gcry((_a)))
	int openpgp_cipher_blocklen (cipher_algo_t algo);
	int openpgp_cipher_test_algo(cipher_algo_t algo);
	const char *openpgp_cipher_algo_name (cipher_algo_t algo);

	pubkey_algo_t map_pk_gcry_to_openpgp (enum gcry_pk_algos algo);
	int openpgp_pk_test_algo (pubkey_algo_t algo);
	int openpgp_pk_test_algo2 (pubkey_algo_t algo, unsigned int use);
	int openpgp_pk_algo_usage ( int algo );
	const char *openpgp_pk_algo_name (pubkey_algo_t algo);

	enum gcry_md_algos map_md_openpgp_to_gcry (digest_algo_t algo);
	int openpgp_md_test_algo (digest_algo_t algo);
	const char *openpgp_md_algo_name (int algo);

	struct expando_args
	{
	PKT_public_key *pk;
	PKT_public_key *pksk;
	byte imagetype;
	int validity_info;
	const char *validity_string;
	const byte *namehash;
	};

	char pct_expando(const char string,struct expando_args *args);
	void deprecated_warning(const char *configname,unsigned int configlineno,
	const char option,const char repl1,const char *repl2);
	void deprecated_command (const char *name);
	void obsolete_scdaemon_option (const char *configname,
	unsigned int configlineno, const char *name);

	int string_to_cipher_algo (const char *string);
	int string_to_digest_algo (const char *string);

	const char *compress_algo_to_string(int algo);
	int string_to_compress_algo(const char *string);
	int check_compress_algo(int algo);
	int default_cipher_algo(void);
	int default_compress_algo(void);
	const char *compliance_option_string(void);
	void compliance_failure(void);

	struct parse_options
	{
	char *name;
	unsigned int bit;
	char **value;
	char *help;
	};

	char optsep(char *stringp);
	char argsplit(char string);
	int parse_options(char str,unsigned int options,
	struct parse_options *opts,int noisy);
	const char *get_libexecdir (void);
	int path_access(const char *file,int mode);

	int pubkey_get_npkey (pubkey_algo_t algo);
	int pubkey_get_nskey (pubkey_algo_t algo);
	int pubkey_get_nsig (pubkey_algo_t algo);
	int pubkey_get_nenc (pubkey_algo_t algo);

	/* Temporary helpers. */
	unsigned int pubkey_nbits( int algo, gcry_mpi_t *pkey );
	int mpi_print (estream_t stream, gcry_mpi_t a, int mode);
	unsigned int ecdsa_qbits_from_Q (unsigned int qbits);


	/-- cpr.c --/
	void set_status_fd ( int fd );
	int is_status_enabled ( void );
	void write_status ( int no );
	void write_status_error (const char *where, gpg_error_t err);
	void write_status_errcode (const char *where, int errcode);
	void write_status_failure (const char *where, gpg_error_t err);
	void write_status_text ( int no, const char *text );
	void write_status_strings (int no, const char *text,
	...) GPGRT_ATTR_SENTINEL(0);
	void write_status_buffer ( int no,
	const char *buffer, size_t len, int wrap );
	void write_status_text_and_buffer ( int no, const char *text,
	const char *buffer, size_t len, int wrap );

	void write_status_begin_signing (gcry_md_hd_t md);


	int cpr_enabled(void);
	char cpr_get( const char keyword, const char *prompt );
	char cpr_get_no_help( const char keyword, const char *prompt );
	char cpr_get_utf8( const char keyword, const char *prompt );
	char cpr_get_hidden( const char keyword, const char *prompt );
	void cpr_kill_prompt(void);
	int cpr_get_answer_is_yes_def (const char keyword, const char prompt,
	int def_yes);
	int cpr_get_answer_is_yes( const char keyword, const char prompt );
	int cpr_get_answer_yes_no_quit( const char keyword, const char prompt );
	int cpr_get_answer_okay_cancel (const char *keyword,
	const char *prompt,
	int def_answer);

	/-- helptext.c --/
	void display_online_help( const char *keyword );

	/-- encode.c --/
	int setup_symkey (STRING2KEY symkey_s2k,DEK symkey_dek);
	void encrypt_seskey (DEK dek, DEK seskey, byte enckey);
	int use_mdc (pk_list_t pk_list,int algo);
	int encrypt_symmetric (const char *filename );
	int encrypt_store (const char *filename );
	int encrypt_crypt (ctrl_t ctrl, int filefd, const char *filename,
	strlist_t remusr, int use_symkey, pk_list_t provided_keys,
	int outputfd);
	void encrypt_crypt_files (ctrl_t ctrl,
	int nfiles, char **files, strlist_t remusr);
	int encrypt_filter (void *opaque, int control,
	iobuf_t a, byte buf, size_t ret_len);

	int write_pubkey_enc (PKT_public_key *pk, int throw_keyid,
	DEK *dek, iobuf_t out);

	/-- sign.c --/
	int complete_sig (PKT_signature sig, PKT_public_key pksk, gcry_md_hd_t md,
	const char *cache_nonce);
	int sign_file (ctrl_t ctrl, strlist_t filenames, int detached, strlist_t locusr,
	int do_encrypt, strlist_t remusr, const char *outfile );
	int clearsign_file (ctrl_t ctrl,
	const char fname, strlist_t locusr, const char outfile);
	int sign_symencrypt_file (ctrl_t ctrl, const char *fname, strlist_t locusr);

	/-- sig-check.c --/

	/* SIG is a revocation signature. Check if any of PK's designated
	revokers generated it. If so, return 0. Note: this function
	(correctly) doesn't care if the designated revoker is revoked. */
	int check_revocation_keys (PKT_public_key pk, PKT_signature sig);
	/* Check that the backsig BACKSIG from the subkey SUB_PK to its
	primary key MAIN_PK is valid. */
	int check_backsig(PKT_public_key main_pk,PKT_public_key sub_pk,
	PKT_signature *backsig);
	/* Check that the signature SIG over a key (e.g., a key binding or a
	key revocation) is valid. (To check signatures over data, use
	check_signature.) */
	int check_key_signature( KBNODE root, KBNODE sig, int *is_selfsig );
	/* Like check_key_signature, but with the ability to specify some
	additional parameters and get back additional information. See the
	documentation for the implementation for details. */
	int check_key_signature2( KBNODE root, KBNODE node, PKT_public_key *check_pk,
	PKT_public_key ret_pk, int is_selfsig,
	u32 r_expiredate, int r_expired );

	/* Returns whether SIGNER generated the signature SIG over the packet
	PACKET, which is a key, subkey or uid, and comes from the key block
	KB. If SIGNER is NULL, it is looked up based on the information in
	SIG. If not NULL, sets *IS_SELFSIG to indicate whether the
	signature is a self-signature and *RET_PK to a copy of the signer's
	key. */
	gpg_error_t check_signature_over_key_or_uid (PKT_public_key *signer,
	PKT_signature *sig,
	KBNODE kb, PACKET *packet,
	int *is_selfsig,
	PKT_public_key *ret_pk);


	/-- delkey.c --/
	gpg_error_t delete_keys (strlist_t names, int secret, int allow_both);

	/-- keyedit.c --/
	void keyedit_menu (ctrl_t ctrl, const char *username, strlist_t locusr,
	strlist_t commands, int quiet, int seckey_check );
	void keyedit_passwd (ctrl_t ctrl, const char *username);
	void keyedit_quick_adduid (ctrl_t ctrl, const char *username,
	const char *newuid);
	void keyedit_quick_addkey (ctrl_t ctrl, const char fpr, const char algostr,
	const char usagestr, const char expirestr);
	void keyedit_quick_revuid (ctrl_t ctrl, const char *username,
	const char *uidtorev);
	void keyedit_quick_sign (ctrl_t ctrl, const char *fpr,
	strlist_t uids, strlist_t locusr, int local);
	void show_basic_key_info (KBNODE keyblock);

	/-- keygen.c --/
	u32 parse_expire_string(const char *string);
	u32 ask_expire_interval(int object,const char *def_expire);
	u32 ask_expiredate(void);
	unsigned int ask_key_flags (int algo, int subkey, unsigned int current);
	void quick_generate_keypair (ctrl_t ctrl, const char uid, const char algostr,
	const char usagestr, const char expirestr);
	void generate_keypair (ctrl_t ctrl, int full, const char *fname,
	const char *card_serialno, int card_backup_key);
	int keygen_set_std_prefs (const char *string,int personal);
	PKT_user_id *keygen_get_std_prefs (void);
	int keygen_add_key_expire( PKT_signature sig, void opaque );
	int keygen_add_key_flags (PKT_signature sig, void opaque);
	int keygen_add_std_prefs( PKT_signature sig, void opaque );
	int keygen_upd_std_prefs( PKT_signature sig, void opaque );
	int keygen_add_keyserver_url(PKT_signature sig, void opaque);
	int keygen_add_notations(PKT_signature sig,void opaque);
	int keygen_add_revkey(PKT_signature sig, void opaque);
	gpg_error_t make_backsig (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 generate_subkeypair (ctrl_t ctrl, kbnode_t keyblock,
	const char *algostr,
	const char *usagestr,
	const char *expirestr);
	#ifdef ENABLE_CARD_SUPPORT
	gpg_error_t generate_card_subkeypair (kbnode_t pub_keyblock,
	int keyno, const char *serialno);
	#endif


	/-- openfile.c --/
	int overwrite_filep( const char *fname );
	char make_outfile_name( const char iname );
	char ask_outfile_name( const char name, size_t namelen );
	int open_outfile (int inp_fd, const char *iname, int mode,
	int restrictedperm, iobuf_t *a);
	char get_matching_datafile (const char sigfilename);
	iobuf_t open_sigfile (const char sigfilename, progress_filter_context_t pfx);
	void try_make_homedir( const char *fname );
	char get_openpgp_revocdir (const char home);

	/-- seskey.c --/
	void make_session_key( DEK *dek );
	gcry_mpi_t encode_session_key( int openpgp_pk_algo, DEK *dek, unsigned nbits );
	gcry_mpi_t encode_md_value (PKT_public_key *pk,
	gcry_md_hd_t md, int hash_algo );

	/-- import.c --/
	struct import_stats_s;
	typedef struct import_stats_s *import_stats_t;
	typedef gpg_error_t (import_screener_t)(kbnode_t keyblock, void arg);

	int parse_import_options(char str,unsigned int options,int noisy);
	gpg_error_t parse_and_set_import_filter (const char *string);
	gpg_error_t read_key_from_file (ctrl_t ctrl, const char *fname,
	kbnode_t *r_keyblock);
	void import_keys (ctrl_t ctrl, char **fnames, int nnames,
	import_stats_t stats_hd, unsigned int options);
	int import_keys_stream (ctrl_t ctrl, iobuf_t inp, import_stats_t stats_hd,
	unsigned char **fpr,
	size_t *fpr_len, unsigned int options);
	int 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);
	gpg_error_t import_old_secring (ctrl_t ctrl, const char *fname);
	import_stats_t import_new_stats_handle (void);
	void import_release_stats_handle (import_stats_t hd);
	void import_print_stats (import_stats_t hd);
	gpg_error_t transfer_secret_keys (ctrl_t ctrl, struct import_stats_s *stats,
	kbnode_t sec_keyblock, int batch, int force);

	int collapse_uids( KBNODE *keyblock );


	/-- export.c --/
	struct export_stats_s;
	typedef struct export_stats_s *export_stats_t;

	export_stats_t export_new_stats (void);
	void export_release_stats (export_stats_t stats);
	void export_print_stats (export_stats_t stats);

	int parse_export_options(char str,unsigned int options,int noisy);
	gpg_error_t parse_and_set_export_filter (const char *string);

	int export_pubkeys (ctrl_t ctrl, strlist_t users, unsigned int options,
	export_stats_t stats);
	int export_seckeys (ctrl_t ctrl, strlist_t users, export_stats_t stats);
	int export_secsubkeys (ctrl_t ctrl, strlist_t users, export_stats_t stats);

	gpg_error_t export_pubkey_buffer (ctrl_t ctrl, const char *keyspec,
	unsigned int options,
	export_stats_t stats,
	kbnode_t *r_keyblock,
	void *r_data, size_t r_datalen);

	gpg_error_t receive_seckey_from_agent (ctrl_t ctrl, gcry_cipher_hd_t cipherhd,
	int cleartext,
	char **cache_nonce_addr,
	const char *hexgrip,
	PKT_public_key *pk);

	-gpg_error_t write_keyblock_to_output (kbnode_t keyblock, int with_armor);
	+gpg_error_t write_keyblock_to_output (kbnode_t keyblock,
	+ int with_armor, unsigned int options);

	gpg_error_t export_ssh_key (ctrl_t ctrl, const char *userid);

	/-- dearmor.c --/
	int dearmor_file( const char *fname );
	int enarmor_file( const char *fname );

	/-- revoke.c --/
	struct revocation_reason_info;
	int gen_standard_revoke (PKT_public_key psk, const char cache_nonce);
	int gen_revoke( const char *uname );
	int gen_desig_revoke (ctrl_t ctrl, const char *uname, strlist_t locusr);
	int revocation_reason_build_cb( PKT_signature sig, void opaque );
	struct revocation_reason_info *
	ask_revocation_reason( int key_rev, int cert_rev, int hint );
	struct revocation_reason_info * get_default_uid_revocation_reason(void);
	void release_revocation_reason_info( struct revocation_reason_info *reason );

	/-- keylist.c --/
	void public_key_list (ctrl_t ctrl, strlist_t list, int locate_mode );
	void secret_key_list (ctrl_t ctrl, strlist_t list );
	void print_subpackets_colon(PKT_signature *sig);
	void reorder_keyblock (KBNODE keyblock);
	void list_keyblock_direct (ctrl_t ctrl, kbnode_t keyblock, int secret,
	int has_secret, int fpr, int no_validity);
	void print_fingerprint (estream_t fp, PKT_public_key *pk, int mode);
	void print_revokers (estream_t fp, PKT_public_key *pk);
	void show_policy_url(PKT_signature *sig,int indent,int mode);
	void show_keyserver_url(PKT_signature *sig,int indent,int mode);
	void show_notation(PKT_signature *sig,int indent,int mode,int which);
	void dump_attribs (const PKT_user_id uid, PKT_public_key pk);
	void set_attrib_fd(int fd);
	char format_seckey_info (PKT_public_key pk);
	void print_seckey_info (PKT_public_key *pk);
	void print_pubkey_info (estream_t fp, PKT_public_key *pk);
	void print_card_key_info (estream_t fp, KBNODE keyblock);
	void print_key_line (estream_t fp, PKT_public_key *pk, int secret);

	/-- verify.c --/
	void print_file_status( int status, const char *name, int what );
	int verify_signatures (ctrl_t ctrl, int nfiles, char **files );
	int verify_files (ctrl_t ctrl, int nfiles, char **files );
	int gpg_verify (ctrl_t ctrl, int sig_fd, int data_fd, estream_t out_fp);

	/-- decrypt.c --/
	int decrypt_message (ctrl_t ctrl, const char *filename );
	gpg_error_t decrypt_message_fd (ctrl_t ctrl, int input_fd, int output_fd);
	void decrypt_messages (ctrl_t ctrl, int nfiles, char *files[]);

	/-- plaintext.c --/
	int hash_datafiles( gcry_md_hd_t md, gcry_md_hd_t md2,
	strlist_t files, const char *sigfilename, int textmode);
	int hash_datafile_by_fd ( gcry_md_hd_t md, gcry_md_hd_t md2, int data_fd,
	int textmode );
	PKT_plaintext setup_plaintext_name(const char filename,IOBUF iobuf);

	/-- server.c --/
	int gpg_server (ctrl_t);
	gpg_error_t gpg_proxy_pinentry_notify (ctrl_t ctrl,
	const unsigned char *line);

	#ifdef ENABLE_CARD_SUPPORT
	/-- card-util.c --/
	void change_pin (int no, int allow_admin);
	void card_status (estream_t fp, char *serialno, size_t serialnobuflen);
	void card_edit (ctrl_t ctrl, strlist_t commands);
	gpg_error_t card_generate_subkey (KBNODE pub_keyblock);
	int card_store_subkey (KBNODE node, int use);
	#endif

	#define S2K_DECODE_COUNT(_val) ((16ul + ((_val) & 15)) << (((_val) >> 4) + 6))

	/-- migrate.c --/
	void migrate_secring (ctrl_t ctrl);


	#endif /G10_MAIN_H/

File Metadata

Mime Type: text/x-diff
Expires: Sun, Feb 23, 7:17 PM (5 h, 7 m)
Storage Engine: local-disk
Storage Format: Raw Data
Storage Handle: c3/e4/5cd77d754a34ff52f0d75c0f8657

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions