No OneTemporary
Actions

Size

7 MB

Subscribers

None

View Options

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

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

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

	#include "gpg.h"
	#include "../common/iobuf.h"
	#include "filter.h"
	#include "keydb.h"
	#include "../common/status.h"
	#include "exec.h"
	#include "main.h"
	#include "../common/i18n.h"
	#include "../common/ttyio.h"
	#include "options.h"
	#include "packet.h"
	#include "trustdb.h"
	#include "keyserver-internal.h"
	#include "../common/util.h"
	#include "../common/membuf.h"
	#include "../common/mbox-util.h"
	#include "call-dirmngr.h"

	#ifdef HAVE_W32_SYSTEM
	/* It seems Vista doesn't grok X_OK and so fails access() tests.
	Previous versions interpreted X_OK as F_OK anyway, so we'll just
	use F_OK directly. */
	#undef X_OK
	#define X_OK F_OK
	#endif /* HAVE_W32_SYSTEM */

	struct keyrec
	{
	KEYDB_SEARCH_DESC desc;
	u32 createtime,expiretime;
	int size,flags;
	byte type;
	IOBUF uidbuf;
	unsigned int lines;
	};

	/* Parameters for the search line handler. */
	struct search_line_handler_parm_s
	{
	ctrl_t ctrl; /* The session control structure. */
	char searchstr_disp; / Native encoded search string or NULL. */
	KEYDB_SEARCH_DESC desc; / Array with search descriptions. */
	int count; /* Number of keys we are currently prepared to
	handle. This is the size of the DESC array. If
	it is too small, it will grow safely. */
	int validcount; /* Enable the "Key x-y of z" messages. */
	int nkeys; /* Number of processed records. */
	int any_lines; /* At least one line has been processed. */
	unsigned int numlines; /* Counter for displayed lines. */
	int eof_seen; /* EOF encountered. */
	int not_found; /* Set if no keys have been found. */
	};


	enum ks_action {KS_UNKNOWN=0,KS_GET,KS_GETNAME,KS_SEND,KS_SEARCH};

	static struct parse_options keyserver_opts[]=
	{
	/* some of these options are not real - just for the help
	message */
	{"max-cert-size",0,NULL,NULL}, /* MUST be the first in this array! */
	{"http-proxy", KEYSERVER_HTTP_PROXY, NULL, /* MUST be the second! */
	N_("override proxy options set for dirmngr")},

	{"include-revoked",0,NULL,N_("include revoked keys in search results")},
	{"include-subkeys",0,NULL,N_("include subkeys when searching by key ID")},
	{"timeout", KEYSERVER_TIMEOUT, NULL,
	N_("override timeout options set for dirmngr")},
	{"refresh-add-fake-v3-keyids",KEYSERVER_ADD_FAKE_V3,NULL,
	NULL},
	{"auto-key-retrieve",KEYSERVER_AUTO_KEY_RETRIEVE,NULL,
	N_("automatically retrieve keys when verifying signatures")},
	{"honor-keyserver-url",KEYSERVER_HONOR_KEYSERVER_URL,NULL,
	N_("honor the preferred keyserver URL set on the key")},
	{"honor-pka-record",KEYSERVER_HONOR_PKA_RECORD,NULL,
	N_("honor the PKA record set on a key when retrieving keys")},
	{NULL,0,NULL,NULL}
	};

	static gpg_error_t keyserver_get (ctrl_t ctrl,
	KEYDB_SEARCH_DESC *desc, int ndesc,
	struct keyserver_spec *override_keyserver,
	unsigned int flags,
	unsigned char *r_fpr, size_t r_fprlen);
	static gpg_error_t keyserver_put (ctrl_t ctrl, strlist_t keyspecs);


	/* Reasonable guess. The commonly used test key simon.josefsson.org
	is larger than 32k, thus we need at least this value. */
	#define DEFAULT_MAX_CERT_SIZE 65536

	static size_t max_cert_size=DEFAULT_MAX_CERT_SIZE;


	static void
	warn_kshelper_option(char *option, int noisy)
	{
	char *p;

	if ((p=strchr (option, '=')))
	*p = 0;

	if (!strcmp (option, "ca-cert-file"))
	log_info ("keyserver option '%s' is obsolete; please use "
	"'%s' in dirmngr.conf\n",
	"ca-cert-file", "hkp-cacert");
	else if (!strcmp (option, "check-cert")
	\|\| !strcmp (option, "broken-http-proxy"))
	log_info ("keyserver option '%s' is obsolete\n", option);
	else if (noisy \|\| opt.verbose)
	log_info ("keyserver option '%s' is unknown\n", option);
	}


	/* Called from main to parse the args for --keyserver-options. */
	int
	parse_keyserver_options(char *options)
	{
	int ret=1;
	char *tok;
	char *max_cert=NULL;

	keyserver_opts[0].value=&max_cert;
	keyserver_opts[1].value=&opt.keyserver_options.http_proxy;

	while((tok=optsep(&options)))
	{
	if(tok[0]=='\0')
	continue;

	/* We accept quite a few possible options here - some options to
	handle specially, the keyserver_options list, and import and
	export options that pertain to keyserver operations. */

	if (!parse_options (tok,&opt.keyserver_options.options, keyserver_opts,0)
	&& !parse_import_options(tok,&opt.keyserver_options.import_options,0)
	&& !parse_export_options(tok,&opt.keyserver_options.export_options,0))
	{
	/* All of the standard options have failed, so the option was
	destined for a keyserver plugin as used by GnuPG < 2.1 */
	warn_kshelper_option (tok, 1);
	}
	}

	if(max_cert)
	{
	max_cert_size=strtoul(max_cert,(char **)NULL,10);

	if(max_cert_size==0)
	max_cert_size=DEFAULT_MAX_CERT_SIZE;
	}

	return ret;
	}


	void
	free_keyserver_spec(struct keyserver_spec *keyserver)
	{
	xfree(keyserver->uri);
	xfree(keyserver);
	}

	/* Return 0 for match */
	static int
	cmp_keyserver_spec(struct keyserver_spec one, struct keyserver_spec two)
	{
	return !!ascii_strcasecmp(one->uri, two->uri);
	}


	/* Try and match one of our keyservers. If we can, return that. If
	we can't, return our input. */
	struct keyserver_spec *
	keyserver_match(struct keyserver_spec *spec)
	{
	struct keyserver_spec *ks;

	for(ks=opt.keyserver;ks;ks=ks->next)
	if(cmp_keyserver_spec(spec,ks)==0)
	return ks;

	return spec;
	}


	/* Create a new keyserver object from STRING. Unless REQUIRE_SCHEME
	* is set a missing scheme is replaced by "hkp://". The data structure
	* could be much easier but in the past we parsed the URI here for the
	* old 2.0 keyserver helpers - which is not anymore needed. */
	keyserver_spec_t
	parse_keyserver_uri (const char *string, int require_scheme)
	{
	struct keyserver_spec *keyserver;
	const char *idx;
	int count;

	log_assert (string);

	keyserver = xcalloc (1, sizeof *keyserver);

	/* Get the scheme */
	for(idx=string, count=0; idx && idx!=':';idx++)
	{
	count++;

	/* Do we see the start of an RFC-2732 ipv6 address here? If so,
	there clearly isn't a scheme so get out early. */
	if(*idx=='[')
	{
	/* Was the '[' the first thing in the string? If not, we
	have a mangled scheme with a [ in it so fail. */
	if(count==1)
	break;
	else
	goto fail;
	}
	}

	if(count==0)
	goto fail;

	if(idx=='\0' \|\| idx=='[')
	{
	if(require_scheme)
	return NULL;

	/* Assume HKP if there is no scheme */
	keyserver->uri = xstrconcat ("hkp://", string, NULL);
	}
	else
	{
	keyserver->uri = xstrdup (string);
	}

	return keyserver;

	fail:
	free_keyserver_spec(keyserver);
	return NULL;
	}


	struct keyserver_spec *
	parse_preferred_keyserver(PKT_signature *sig)
	{
	struct keyserver_spec *spec=NULL;
	const byte *p;
	size_t plen;

	p=parse_sig_subpkt(sig->hashed,SIGSUBPKT_PREF_KS,&plen);
	if(p && plen)
	{
	byte *dupe=xmalloc(plen+1);

	memcpy(dupe,p,plen);
	dupe[plen]='\0';
	spec = parse_keyserver_uri (dupe, 1);
	xfree(dupe);
	}

	return spec;
	}

	static void
	print_keyrec (ctrl_t ctrl, int number,struct keyrec *keyrec)
	{
	int i;

	iobuf_writebyte(keyrec->uidbuf,0);
	iobuf_flush_temp(keyrec->uidbuf);
	es_printf ("(%d)\t%s ", number, iobuf_get_temp_buffer (keyrec->uidbuf));

	if (keyrec->size>0)
	es_printf ("%d bit ", keyrec->size);

	if(keyrec->type)
	{
	const char *str;

	str = openpgp_pk_algo_name (keyrec->type);

	if (str && strcmp (str, "?"))
	es_printf ("%s ",str);
	else
	es_printf ("unknown ");
	}

	switch(keyrec->desc.mode)
	{
	/* If the keyserver helper gave us a short keyid, we have no
	choice but to use it. Do check --keyid-format to add a 0x if
	needed. */
	case KEYDB_SEARCH_MODE_SHORT_KID:
	es_printf ("key %s%08lX",
	(opt.keyid_format==KF_0xSHORT
	\|\| opt.keyid_format==KF_0xLONG)?"0x":"",
	(ulong)keyrec->desc.u.kid[1]);
	break;

	/* However, if it gave us a long keyid, we can honor
	--keyid-format via keystr(). */
	case KEYDB_SEARCH_MODE_LONG_KID:
	es_printf ("key %s",keystr(keyrec->desc.u.kid));
	break;

	/* If it gave us a PGP 2.x fingerprint, not much we can do
	beyond displaying it. */
	case KEYDB_SEARCH_MODE_FPR16:
	es_printf ("key ");
	for(i=0;i<16;i++)
	es_printf ("%02X",keyrec->desc.u.fpr[i]);
	break;

	/* If we get a modern fingerprint, we have the most
	flexibility. */
	case KEYDB_SEARCH_MODE_FPR20:
	{
	u32 kid[2];
	keyid_from_fingerprint (ctrl, keyrec->desc.u.fpr,20,kid);
	es_printf("key %s",keystr(kid));
	}
	break;

	default:
	BUG();
	break;
	}

	if(keyrec->createtime>0)
	{
	es_printf (", ");
	es_printf (_("created: %s"), strtimestamp(keyrec->createtime));
	}

	if(keyrec->expiretime>0)
	{
	es_printf (", ");
	es_printf (_("expires: %s"), strtimestamp(keyrec->expiretime));
	}

	if (keyrec->flags&1)
	es_printf (" (%s)", _("revoked"));
	if(keyrec->flags&2)
	es_printf (" (%s)", _("disabled"));
	if(keyrec->flags&4)
	es_printf (" (%s)", _("expired"));

	es_printf ("\n");
	}

	/* Returns a keyrec (which must be freed) once a key is complete, and
	NULL otherwise. Call with a NULL keystring once key parsing is
	complete to return any unfinished keys. */
	static struct keyrec *
	parse_keyrec(char *keystring)
	{
	/* FIXME: Remove the static and put the data into the parms we use
	for the caller anyway. */
	static struct keyrec *work=NULL;
	struct keyrec *ret=NULL;
	char *record;
	int i;

	if(keystring==NULL)
	{
	if(work==NULL)
	return NULL;
	else if(work->desc.mode==KEYDB_SEARCH_MODE_NONE)
	{
	xfree(work);
	return NULL;
	}
	else
	{
	ret=work;
	work=NULL;
	return ret;
	}
	}

	if(work==NULL)
	{
	work=xmalloc_clear(sizeof(struct keyrec));
	work->uidbuf=iobuf_temp();
	}

	trim_trailing_ws (keystring, strlen (keystring));

	if((record=strsep(&keystring,":"))==NULL)
	return ret;

	if(ascii_strcasecmp("pub",record)==0)
	{
	char *tok;
	gpg_error_t err;

	if(work->desc.mode)
	{
	ret=work;
	work=xmalloc_clear(sizeof(struct keyrec));
	work->uidbuf=iobuf_temp();
	}

	if((tok=strsep(&keystring,":"))==NULL)
	return ret;

	err = classify_user_id (tok, &work->desc, 1);
	if (err \|\| (work->desc.mode != KEYDB_SEARCH_MODE_SHORT_KID
	&& work->desc.mode != KEYDB_SEARCH_MODE_LONG_KID
	&& work->desc.mode != KEYDB_SEARCH_MODE_FPR16
	&& work->desc.mode != KEYDB_SEARCH_MODE_FPR20))
	{
	work->desc.mode=KEYDB_SEARCH_MODE_NONE;
	return ret;
	}

	/* Note all items after this are optional. This allows us to
	have a pub line as simple as pub:keyid and nothing else. */

	work->lines++;

	if((tok=strsep(&keystring,":"))==NULL)
	return ret;

	work->type=atoi(tok);

	if((tok=strsep(&keystring,":"))==NULL)
	return ret;

	work->size=atoi(tok);

	if((tok=strsep(&keystring,":"))==NULL)
	return ret;

	if(atoi(tok)<=0)
	work->createtime=0;
	else
	work->createtime=atoi(tok);

	if((tok=strsep(&keystring,":"))==NULL)
	return ret;

	if(atoi(tok)<=0)
	work->expiretime=0;
	else
	{
	work->expiretime=atoi(tok);
	/* Force the 'e' flag on if this key is expired. */
	if(work->expiretime<=make_timestamp())
	work->flags\|=4;
	}

	if((tok=strsep(&keystring,":"))==NULL)
	return ret;

	while(*tok)
	switch(*tok++)
	{
	case 'r':
	case 'R':
	work->flags\|=1;
	break;

	case 'd':
	case 'D':
	work->flags\|=2;
	break;

	case 'e':
	case 'E':
	work->flags\|=4;
	break;
	}
	}
	else if(ascii_strcasecmp("uid",record)==0 && work->desc.mode)
	{
	char userid,tok,*decoded;

	if((tok=strsep(&keystring,":"))==NULL)
	return ret;

	if(strlen(tok)==0)
	return ret;

	userid=tok;

	/* By definition, de-%-encoding is always smaller than the
	original string so we can decode in place. */

	i=0;

	while(*tok)
	if(tok[0]=='%' && tok[1] && tok[2])
	{
	int c;

	userid[i] = (c=hextobyte(&tok[1])) == -1 ? '?' : c;
	i++;
	tok+=3;
	}
	else
	userid[i++]=*tok++;

	/* We don't care about the other info provided in the uid: line
	since no keyserver supports marking userids with timestamps
	or revoked/expired/disabled yet. */

	/* No need to check for control characters, as utf8_to_native
	does this for us. */

	decoded=utf8_to_native(userid,i,0);
	if(strlen(decoded)>opt.screen_columns-10)
	decoded[opt.screen_columns-10]='\0';
	iobuf_writestr(work->uidbuf,decoded);
	xfree(decoded);
	iobuf_writestr(work->uidbuf,"\n\t");
	work->lines++;
	}

	/* Ignore any records other than "pri" and "uid" for easy future
	growth. */

	return ret;
	}

	/* Show a prompt and allow the user to select keys for retrieval. */
	static gpg_error_t
	show_prompt (ctrl_t ctrl, KEYDB_SEARCH_DESC *desc, int numdesc,
	int count, const char *search)
	{
	gpg_error_t err;
	char *answer = NULL;

	es_fflush (es_stdout);

	if (count && opt.command_fd == -1)
	{
	static int from = 1;
	tty_printf ("Keys %d-%d of %d for \"%s\". ",
	from, numdesc, count, search);
	from = numdesc + 1;
	}

	again:
	err = 0;
	xfree (answer);
	answer = cpr_get_no_help ("keysearch.prompt",
	_("Enter number(s), N)ext, or Q)uit > "));
	/* control-d */
	if (answer[0]=='\x04')
	{
	tty_printf ("Q\n");
	answer[0] = 'q';
	}

	if (answer[0]=='q' \|\| answer[0]=='Q')
	err = gpg_error (GPG_ERR_CANCELED);
	else if (atoi (answer) >= 1 && atoi (answer) <= numdesc)
	{
	char *split = answer;
	char *num;
	int numarray[50];
	int numidx = 0;
	int idx;

	while ((num = strsep (&split, " ,")))
	if (atoi (num) >= 1 && atoi (num) <= numdesc)
	{
	if (numidx >= DIM (numarray))
	{
	tty_printf ("Too many keys selected\n");
	goto again;
	}
	numarray[numidx++] = atoi (num);
	}

	if (!numidx)
	goto again;

	{
	KEYDB_SEARCH_DESC *selarray;

	selarray = xtrymalloc (numidx * sizeof *selarray);
	if (!selarray)
	{
	err = gpg_error_from_syserror ();
	goto leave;
	}
	for (idx = 0; idx < numidx; idx++)
	selarray[idx] = desc[numarray[idx]-1];
	err = keyserver_get (ctrl, selarray, numidx, NULL, 0, NULL, NULL);
	xfree (selarray);
	}
	}

	leave:
	xfree (answer);
	return err;
	}


	/* This is a callback used by call-dirmngr.c to process the result of
	KS_SEARCH command. If SPECIAL is 0, LINE is the actual data line
	received with all escaping removed and guaranteed to be exactly one
	line with stripped LF; an EOF is indicated by LINE passed as NULL.
	If special is 1, the line contains the source of the information
	(usually an URL). LINE may be modified after return. */
	static gpg_error_t
	search_line_handler (void opaque, int special, char line)
	{
	struct search_line_handler_parm_s *parm = opaque;
	gpg_error_t err = 0;
	struct keyrec *keyrec;

	if (special == 1)
	{
	log_info ("data source: %s\n", line);
	return 0;
	}
	else if (special)
	{
	log_debug ("unknown value %d for special search callback", special);
	return 0;
	}

	if (parm->eof_seen && line)
	{
	log_debug ("ooops: unexpected data after EOF\n");
	line = NULL;
	}

	/* Print the received line. */
	if (opt.with_colons && line)
	{
	es_printf ("%s\n", line);
	}

	/* Look for an info: line. The only current info: values defined
	are the version and key count. */
	if (line && !parm->any_lines && !ascii_strncasecmp ("info:", line, 5))
	{
	char *str = line + 5;
	char *tok;

	if ((tok = strsep (&str, ":")))
	{
	int version;

	if (sscanf (tok, "%d", &version) !=1 )
	version = 1;

	if (version !=1 )
	{
	log_error (_("invalid keyserver protocol "
	"(us %d!=handler %d)\n"), 1, version);
	return gpg_error (GPG_ERR_UNSUPPORTED_PROTOCOL);
	}
	}

	if ((tok = strsep (&str, ":"))
	&& sscanf (tok, "%d", &parm->count) == 1)
	{
	if (!parm->count)
	parm->not_found = 1;/* Server indicated that no items follow. */
	else if (parm->count < 0)
	parm->count = 10; /* Bad value - assume something reasonable. */
	else
	parm->validcount = 1; /* COUNT seems to be okay. */
	}

	parm->any_lines = 1;
	return 0; /* Line processing finished. */
	}

	again:
	if (line)
	keyrec = parse_keyrec (line);
	else
	{
	/* Received EOF - flush data */
	parm->eof_seen = 1;
	keyrec = parse_keyrec (NULL);
	if (!keyrec)
	{
	if (!parm->nkeys)
	parm->not_found = 1; /* No keys at all. */
	else
	{
	if (parm->nkeys != parm->count)
	parm->validcount = 0;

	if (!(opt.with_colons && opt.batch))
	{
	err = show_prompt (parm->ctrl, parm->desc, parm->nkeys,
	parm->validcount? parm->count : 0,
	parm->searchstr_disp);
	return err;
	}
	}
	}
	}

	/* Save the key in the key array. */
	if (keyrec)
	{
	/* Allocate or enlarge the key array if needed. */
	if (!parm->desc)
	{
	if (parm->count < 1)
	{
	parm->count = 10;
	parm->validcount = 0;
	}
	parm->desc = xtrymalloc (parm->count * sizeof *parm->desc);
	if (!parm->desc)
	{
	err = gpg_error_from_syserror ();
	iobuf_close (keyrec->uidbuf);
	xfree (keyrec);
	return err;
	}
	}
	else if (parm->nkeys == parm->count)
	{
	/* Keyserver sent more keys than claimed in the info: line. */
	KEYDB_SEARCH_DESC *tmp;
	int newcount = parm->count + 10;

	tmp = xtryrealloc (parm->desc, newcount * sizeof *parm->desc);
	if (!tmp)
	{
	err = gpg_error_from_syserror ();
	iobuf_close (keyrec->uidbuf);
	xfree (keyrec);
	return err;
	}
	parm->count = newcount;
	parm->desc = tmp;
	parm->validcount = 0;
	}

	parm->desc[parm->nkeys] = keyrec->desc;

	if (!opt.with_colons)
	{
	/* SCREEN_LINES - 1 for the prompt. */
	if (parm->numlines + keyrec->lines > opt.screen_lines - 1)
	{
	err = show_prompt (parm->ctrl, parm->desc, parm->nkeys,
	parm->validcount ? parm->count:0,
	parm->searchstr_disp);
	if (err)
	return err;
	parm->numlines = 0;
	}

	print_keyrec (parm->ctrl, parm->nkeys+1, keyrec);
	}

	parm->numlines += keyrec->lines;
	iobuf_close (keyrec->uidbuf);
	xfree (keyrec);

	parm->any_lines = 1;
	parm->nkeys++;

	/* If we are here due to a flush after the EOF, run again for
	the last prompt. Fixme: Make this code better readable. */
	if (parm->eof_seen)
	goto again;
	}

	return 0;
	}



	int
	keyserver_export (ctrl_t ctrl, strlist_t users)
	{
	gpg_error_t err;
	strlist_t sl=NULL;
	KEYDB_SEARCH_DESC desc;
	int rc=0;

	/* Weed out descriptors that we don't support sending */
	for(;users;users=users->next)
	{
	err = classify_user_id (users->d, &desc, 1);
	if (err \|\| (desc.mode != KEYDB_SEARCH_MODE_SHORT_KID
	&& desc.mode != KEYDB_SEARCH_MODE_LONG_KID
	&& desc.mode != KEYDB_SEARCH_MODE_FPR16
	&& desc.mode != KEYDB_SEARCH_MODE_FPR20))
	{
	log_error(_("\"%s\" not a key ID: skipping\n"),users->d);
	continue;
	}
	else
	append_to_strlist(&sl,users->d);
	}

	if(sl)
	{
	rc = keyserver_put (ctrl, sl);
	free_strlist(sl);
	}

	return rc;
	}


	/* Structure to convey the arg to keyserver_retrieval_screener. */
	struct ks_retrieval_screener_arg_s
	{
	KEYDB_SEARCH_DESC *desc;
	int ndesc;
	};


	/* Check whether a key matches the search description. The function
	returns 0 if the key shall be imported. */
	static gpg_error_t
	keyserver_retrieval_screener (kbnode_t keyblock, void *opaque)
	{
	struct ks_retrieval_screener_arg_s *arg = opaque;
	KEYDB_SEARCH_DESC *desc = arg->desc;
	int ndesc = arg->ndesc;
	kbnode_t node;
	PKT_public_key *pk;
	int n;
	u32 keyid[2];
	byte fpr[MAX_FINGERPRINT_LEN];
	size_t fpr_len = 0;

	/* Secret keys are not expected from a keyserver. We do not
	care about secret subkeys because the import code takes care
	of skipping them. Not allowing an import of a public key
	with a secret subkey would make it too easy to inhibit the
	downloading of a public key. Recall that keyservers do only
	limited checks. */
	node = find_kbnode (keyblock, PKT_SECRET_KEY);
	if (node)
	return gpg_error (GPG_ERR_GENERAL); /* Do not import. */

	if (!ndesc)
	return 0; /* Okay if no description given. */

	/* Loop over all key packets. */
	for (node = keyblock; node; node = node->next)
	{
	if (node->pkt->pkttype != PKT_PUBLIC_KEY
	&& node->pkt->pkttype != PKT_PUBLIC_SUBKEY)
	continue;

	pk = node->pkt->pkt.public_key;
	fingerprint_from_pk (pk, fpr, &fpr_len);
	keyid_from_pk (pk, keyid);

	/* Compare requested and returned fingerprints if available. */
	for (n = 0; n < ndesc; n++)
	{
	if (desc[n].mode == KEYDB_SEARCH_MODE_FPR20)
	{
	if (fpr_len == 20 && !memcmp (fpr, desc[n].u.fpr, 20))
	return 0;
	}
	else if (desc[n].mode == KEYDB_SEARCH_MODE_FPR16)
	{
	if (fpr_len == 16 && !memcmp (fpr, desc[n].u.fpr, 16))
	return 0;
	}
	else if (desc[n].mode == KEYDB_SEARCH_MODE_LONG_KID)
	{
	if (keyid[0] == desc[n].u.kid[0] && keyid[1] == desc[n].u.kid[1])
	return 0;
	}
	else if (desc[n].mode == KEYDB_SEARCH_MODE_SHORT_KID)
	{
	if (keyid[1] == desc[n].u.kid[1])
	return 0;
	}
	else /* No keyid or fingerprint - can't check. */
	return 0; /* allow import. */
	}
	}

	return gpg_error (GPG_ERR_GENERAL);
	}


	int
	keyserver_import (ctrl_t ctrl, strlist_t users)
	{
	gpg_error_t err;
	KEYDB_SEARCH_DESC *desc;
	int num=100,count=0;
	int rc=0;

	/* Build a list of key ids */
	desc=xmalloc(sizeof(KEYDB_SEARCH_DESC)*num);

	for(;users;users=users->next)
	{
	err = classify_user_id (users->d, &desc[count], 1);
	if (err \|\| (desc[count].mode != KEYDB_SEARCH_MODE_SHORT_KID
	&& desc[count].mode != KEYDB_SEARCH_MODE_LONG_KID
	&& desc[count].mode != KEYDB_SEARCH_MODE_FPR16
	&& desc[count].mode != KEYDB_SEARCH_MODE_FPR20))
	{
	log_error (_("\"%s\" not a key ID: skipping\n"), users->d);
	continue;
	}

	count++;
	if(count==num)
	{
	num+=100;
	desc=xrealloc(desc,sizeof(KEYDB_SEARCH_DESC)*num);
	}
	}

	if(count>0)
	rc = keyserver_get (ctrl, desc, count, NULL, 0, NULL, NULL);

	xfree(desc);

	return rc;
	}


	/* Return true if any keyserver has been configured. */
	int
	keyserver_any_configured (ctrl_t ctrl)
	{
	return !gpg_dirmngr_ks_list (ctrl, NULL);
	}


	/* Import all keys that exactly match MBOX */
	int
	keyserver_import_mbox (ctrl_t ctrl, const char *mbox,
	unsigned char *fpr, size_t fprlen,
	struct keyserver_spec *keyserver)
	{
	KEYDB_SEARCH_DESC desc = { 0 };

	desc.mode = KEYDB_SEARCH_MODE_MAIL;
	desc.u.name = mbox;

	return keyserver_get (ctrl, &desc, 1, keyserver, 0, fpr, fprlen);
	}


	/* Import the keys that match exactly MBOX */
	int
	keyserver_import_ntds (ctrl_t ctrl, const char *mbox,
	unsigned char *fpr, size_t fprlen)
	{
	KEYDB_SEARCH_DESC desc = { 0 };
	struct keyserver_spec keyserver = { NULL, "ldap:///" };

	desc.mode = KEYDB_SEARCH_MODE_MAIL;
	desc.u.name = mbox;

	return keyserver_get (ctrl, &desc, 1, &keyserver, 0, fpr, fprlen);
	}


	int
	keyserver_import_fprint (ctrl_t ctrl, const byte *fprint, size_t fprint_len,
	struct keyserver_spec *keyserver,
	unsigned int flags)
	{
	KEYDB_SEARCH_DESC desc;

	memset (&desc, 0, sizeof(desc));

	if(fprint_len==16)
	desc.mode=KEYDB_SEARCH_MODE_FPR16;
	else if(fprint_len==20)
	desc.mode=KEYDB_SEARCH_MODE_FPR20;
	else
	return gpg_error (GPG_ERR_INV_ARG);

	memcpy (desc.u.fpr, fprint, fprint_len);

	return keyserver_get (ctrl, &desc, 1, keyserver, flags, NULL, NULL);
	}


	int
	keyserver_import_fprint_ntds (ctrl_t ctrl,
	const byte *fprint, size_t fprint_len)
	{
	struct keyserver_spec keyserver = { NULL, "ldap:///" };

	return keyserver_import_fprint (ctrl, fprint, fprint_len,
	&keyserver, KEYSERVER_IMPORT_FLAG_LDAP);
	}


	int
	keyserver_import_keyid (ctrl_t ctrl,
	u32 keyid,struct keyserver_spec keyserver,
	unsigned int flags)
	{
	KEYDB_SEARCH_DESC desc;

	memset(&desc,0,sizeof(desc));

	desc.mode=KEYDB_SEARCH_MODE_LONG_KID;
	desc.u.kid[0]=keyid[0];
	desc.u.kid[1]=keyid[1];

	return keyserver_get (ctrl, &desc, 1, keyserver, flags, NULL, NULL);
	}


	/* code mostly stolen from do_export_stream */
	static int
	keyidlist (ctrl_t ctrl, strlist_t users, KEYDB_SEARCH_DESC **klist,
	int *count)
	{
	int rc = 0;
	int num = 100;
	kbnode_t keyblock = NULL;
	kbnode_t node;
	KEYDB_HANDLE kdbhd;
	int ndesc;
	KEYDB_SEARCH_DESC *desc = NULL;
	strlist_t sl;

	*count=0;

	klist=xmalloc(sizeof(KEYDB_SEARCH_DESC)num);

	kdbhd = keydb_new ();
	if (!kdbhd)
	{
	rc = gpg_error_from_syserror ();
	goto leave;
	}
	keydb_disable_caching (kdbhd); /* We are looping the search. */

	if(!users)
	{
	ndesc = 1;
	desc = xmalloc_clear ( 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)
	{
	gpg_error_t err;
	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));
	}
	}

	for (;;)
	{
	rc = keydb_search (kdbhd, desc, ndesc, NULL);
	if (rc)
	break; /* ready. */

	if (!users)
	desc[0].mode = KEYDB_SEARCH_MODE_NEXT;

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

	if((node=find_kbnode(keyblock,PKT_PUBLIC_KEY)))
	{
	/* v4 keys get full fingerprints. v3 keys get long keyids.
	This is because it's easy to calculate any sort of keyid
	from a v4 fingerprint, but not a v3 fingerprint. */

	if(node->pkt->pkt.public_key->version<4)
	{
	(klist)[count].mode=KEYDB_SEARCH_MODE_LONG_KID;
	keyid_from_pk(node->pkt->pkt.public_key,
	(klist)[count].u.kid);
	}
	else
	{
	size_t dummy;

	(klist)[count].mode=KEYDB_SEARCH_MODE_FPR20;
	fingerprint_from_pk(node->pkt->pkt.public_key,
	(klist)[count].u.fpr,&dummy);
	}

	/* This is a little hackish, using the skipfncvalue as a
	void* pointer to the keyserver spec, but we don't need
	the skipfnc here, and it saves having an additional field
	for this (which would be wasted space most of the
	time). */

	(klist)[count].skipfncvalue=NULL;

	/* Are we honoring preferred keyservers? */
	if(opt.keyserver_options.options&KEYSERVER_HONOR_KEYSERVER_URL)
	{
	PKT_user_id *uid=NULL;
	PKT_signature *sig=NULL;

	merge_keys_and_selfsig (ctrl, keyblock);

	for(node=node->next;node;node=node->next)
	{
	if(node->pkt->pkttype==PKT_USER_ID
	&& node->pkt->pkt.user_id->flags.primary)
	uid=node->pkt->pkt.user_id;
	else if(node->pkt->pkttype==PKT_SIGNATURE
	&& node->pkt->pkt.signature->
	flags.chosen_selfsig && uid)
	{
	sig=node->pkt->pkt.signature;
	break;
	}
	}

	/* Try and parse the keyserver URL. If it doesn't work,
	then we end up writing NULL which indicates we are
	the same as any other key. */
	if(sig)
	(klist)[count].skipfncvalue=parse_preferred_keyserver(sig);
	}

	(*count)++;

	if(*count==num)
	{
	num+=100;
	klist=xrealloc(klist,sizeof(KEYDB_SEARCH_DESC)*num);
	}
	}
	}

	if (gpg_err_code (rc) == GPG_ERR_NOT_FOUND)
	rc = 0;

	leave:
	if(rc)
	{
	xfree(*klist);
	*klist = NULL;
	}
	xfree(desc);
	keydb_release(kdbhd);
	release_kbnode(keyblock);

	return rc;
	}

	/* Note this is different than the original HKP refresh. It allows
	usernames to refresh only part of the keyring. */

	gpg_error_t
	keyserver_refresh (ctrl_t ctrl, strlist_t users)
	{
	gpg_error_t err;
	int count, numdesc;
	KEYDB_SEARCH_DESC *desc;
	unsigned int options=opt.keyserver_options.import_options;

	/* We switch merge-only on during a refresh, as 'refresh' should
	never import new keys, even if their keyids match. */
	opt.keyserver_options.import_options\|=IMPORT_MERGE_ONLY;

	/* Similarly, we switch on fast-import, since refresh may make
	multiple import sets (due to preferred keyserver URLs). We don't
	want each set to rebuild the trustdb. Instead we do it once at
	the end here. */
	opt.keyserver_options.import_options\|=IMPORT_FAST;


	err = keyidlist (ctrl, users, &desc, &numdesc);
	if (err)
	return err;

	count=numdesc;
	if(count>0)
	{
	int i;

	/* Try to handle preferred keyserver keys first */
	for(i=0;i<numdesc;i++)
	{
	if(desc[i].skipfncvalue)
	{
	struct keyserver_spec *keyserver=desc[i].skipfncvalue;

	if (!opt.quiet)
	- log_info (_("refreshing %d key from %s\n"), 1, keyserver->uri);
	+ log_info (ngettext("refreshing %d key from %s\n",
	+ "refreshing %d keys from %s\n",
	+ 1), 1, keyserver->uri);

	/* We use the keyserver structure we parsed out before.
	Note that a preferred keyserver without a scheme://
	will be interpreted as hkp:// */
	err = keyserver_get (ctrl, &desc[i], 1, keyserver, 0, NULL, NULL);
	if (err)
	log_info(_("WARNING: unable to refresh key %s"
	" via %s: %s\n"),keystr_from_desc(&desc[i]),
	keyserver->uri,gpg_strerror (err));
	else
	{
	/* We got it, so mark it as NONE so we don't try and
	get it again from the regular keyserver. */

	desc[i].mode=KEYDB_SEARCH_MODE_NONE;
	count--;
	}

	free_keyserver_spec(keyserver);
	}
	}
	}

	if(count>0)
	{
	char *tmpuri;

	err = gpg_dirmngr_ks_list (ctrl, &tmpuri);
	if (!err)
	{
	if (!opt.quiet)
	{
	log_info (ngettext("refreshing %d key from %s\n",
	"refreshing %d keys from %s\n",
	count), count, tmpuri);
	}
	xfree (tmpuri);

	err = keyserver_get (ctrl, desc, numdesc, NULL, 0, NULL, NULL);
	}
	}

	xfree(desc);

	opt.keyserver_options.import_options=options;

	/* If the original options didn't have fast import, and the trustdb
	is dirty, rebuild. */
	if(!(opt.keyserver_options.import_options&IMPORT_FAST))
	check_or_update_trustdb (ctrl);

	return err;
	}


	/* Search for keys on the keyservers. The patterns are given in the
	string list TOKENS. */
	gpg_error_t
	keyserver_search (ctrl_t ctrl, strlist_t tokens)
	{
	gpg_error_t err;
	char *searchstr;
	struct search_line_handler_parm_s parm;

	memset (&parm, 0, sizeof parm);

	if (!tokens)
	return 0; /* Return success if no patterns are given. */

	{
	membuf_t mb;
	strlist_t item;

	init_membuf (&mb, 1024);
	for (item = tokens; item; item = item->next)
	{
	if (item != tokens)
	put_membuf (&mb, " ", 1);
	put_membuf_str (&mb, item->d);
	}
	put_membuf (&mb, "", 1); /* Append Nul. */
	searchstr = get_membuf (&mb, NULL);
	if (!searchstr)
	{
	err = gpg_error_from_syserror ();
	goto leave;
	}
	}

	parm.ctrl = ctrl;
	if (searchstr)
	parm.searchstr_disp = utf8_to_native (searchstr, strlen (searchstr), 0);

	err = gpg_dirmngr_ks_search (ctrl, searchstr, search_line_handler, &parm);

	if (parm.not_found \|\| gpg_err_code (err) == GPG_ERR_NO_DATA)
	{
	if (parm.searchstr_disp)
	log_info (_("key \"%s\" not found on keyserver\n"),
	parm.searchstr_disp);
	else
	log_info (_("key not found on keyserver\n"));
	}

	if (gpg_err_code (err) == GPG_ERR_NO_DATA)
	err = gpg_error (GPG_ERR_NOT_FOUND);
	else if (err)
	log_error ("error searching keyserver: %s\n", gpg_strerror (err));

	leave:
	xfree (parm.desc);
	xfree (parm.searchstr_disp);
	xfree(searchstr);

	return err;
	}

	/* Helper for keyserver_get. Here we only receive a chunk of the
	description to be processed in one batch. This is required due to
	the limited number of patterns the dirmngr interface (KS_GET) can
	grok and to limit the amount of temporary required memory. */
	static gpg_error_t
	keyserver_get_chunk (ctrl_t ctrl, KEYDB_SEARCH_DESC *desc, int ndesc,
	int *r_ndesc_used,
	import_stats_t stats_handle,
	struct keyserver_spec *override_keyserver,
	unsigned int flags,
	unsigned char *r_fpr, size_t r_fprlen)

	{
	gpg_error_t err = 0;
	char **pattern;
	int idx, npat, npat_fpr;
	estream_t datastream;
	char *source = NULL;
	size_t linelen; /* Estimated linelen for KS_GET. */
	size_t n;
	int only_fprs;

	#define MAX_KS_GET_LINELEN 950 /* Somewhat lower than the real limit. */

	*r_ndesc_used = 0;

	/* Create an array filled with a search pattern for each key. The
	array is delimited by a NULL entry. */
	pattern = xtrycalloc (ndesc+1, sizeof *pattern);
	if (!pattern)
	return gpg_error_from_syserror ();

	/* Note that we break the loop as soon as our estimation of the to
	be used line length reaches the limit. But we do this only if we
	have processed at least one search requests so that an overlong
	single request will be rejected only later by gpg_dirmngr_ks_get
	but we are sure that R_NDESC_USED has been updated. This avoids
	a possible indefinite loop. */
	linelen = 24; /* "KS_GET --quick --ldap --" */
	for (npat=npat_fpr=0, idx=0; idx < ndesc; idx++)
	{
	int quiet = 0;

	if (desc[idx].mode == KEYDB_SEARCH_MODE_FPR20
	\|\| desc[idx].mode == KEYDB_SEARCH_MODE_FPR16)
	{
	n = 1+2+2*20;
	if (idx && linelen + n > MAX_KS_GET_LINELEN)
	break; /* Declare end of this chunk. */
	linelen += n;

	pattern[npat] = xtrymalloc (n);
	if (!pattern[npat])
	err = gpg_error_from_syserror ();
	else
	{
	strcpy (pattern[npat], "0x");
	bin2hex (desc[idx].u.fpr,
	desc[idx].mode == KEYDB_SEARCH_MODE_FPR20? 20 : 16,
	pattern[npat]+2);
	npat++;
	if (desc[idx].mode == KEYDB_SEARCH_MODE_FPR20)
	npat_fpr++;
	}
	}
	else if(desc[idx].mode == KEYDB_SEARCH_MODE_LONG_KID)
	{
	n = 1+2+16;
	if (idx && linelen + n > MAX_KS_GET_LINELEN)
	break; /* Declare end of this chunk. */
	linelen += n;

	pattern[npat] = xtryasprintf ("0x%08lX%08lX",
	(ulong)desc[idx].u.kid[0],
	(ulong)desc[idx].u.kid[1]);
	if (!pattern[npat])
	err = gpg_error_from_syserror ();
	else
	npat++;
	}
	else if(desc[idx].mode == KEYDB_SEARCH_MODE_SHORT_KID)
	{
	n = 1+2+8;
	if (idx && linelen + n > MAX_KS_GET_LINELEN)
	break; /* Declare end of this chunk. */
	linelen += n;

	pattern[npat] = xtryasprintf ("0x%08lX", (ulong)desc[idx].u.kid[1]);
	if (!pattern[npat])
	err = gpg_error_from_syserror ();
	else
	npat++;
	}
	else if(desc[idx].mode == KEYDB_SEARCH_MODE_EXACT)
	{
	/* The Dirmngr also uses classify_user_id to detect the type
	of the search string. By adding the '=' prefix we force
	Dirmngr's KS_GET to consider this an exact search string.
	(In gpg 1.4 and gpg 2.0 the keyserver helpers used the
	KS_GETNAME command to indicate this.) */

	n = 1+1+strlen (desc[idx].u.name);
	if (idx && linelen + n > MAX_KS_GET_LINELEN)
	break; /* Declare end of this chunk. */
	linelen += n;

	pattern[npat] = strconcat ("=", desc[idx].u.name, NULL);
	if (!pattern[npat])
	err = gpg_error_from_syserror ();
	else
	{
	npat++;
	quiet = 1;
	}
	}
	else if(desc[idx].mode == KEYDB_SEARCH_MODE_MAIL)
	{
	n = 1 + strlen (desc[idx].u.name) + 1 + 1;
	if (idx && linelen + n > MAX_KS_GET_LINELEN)
	break; /* Declare end of this chunk. */
	linelen += n;

	if (desc[idx].u.name[0] == '<')
	pattern[npat] = xtrystrdup (desc[idx].u.name);
	else
	pattern[npat] = strconcat ("<", desc[idx].u.name, ">", NULL);
	if (!pattern[npat])
	err = gpg_error_from_syserror ();
	else
	{
	npat++;
	quiet = 1;
	}
	}
	else if (desc[idx].mode == KEYDB_SEARCH_MODE_NONE)
	continue;
	else
	BUG();

	if (err)
	{
	for (idx=0; idx < npat; idx++)
	xfree (pattern[idx]);
	xfree (pattern);
	return err;
	}

	if (!quiet && override_keyserver)
	{
	log_info (_("requesting key %s from %s\n"),
	keystr_from_desc (&desc[idx]), override_keyserver->uri);
	}
	}

	/* Remember now many of search items were considered. Note that
	this is different from NPAT. */
	*r_ndesc_used = idx;

	only_fprs = (npat && npat == npat_fpr);

	err = gpg_dirmngr_ks_get (ctrl, pattern, override_keyserver, flags,
	&datastream, &source);
	for (idx=0; idx < npat; idx++)
	xfree (pattern[idx]);
	xfree (pattern);
	if (opt.verbose && source)
	log_info ("data source: %s\n", source);



	if (!err)
	{
	struct ks_retrieval_screener_arg_s screenerarg;
	unsigned int options;

	/* FIXME: Check whether this comment should be moved to dirmngr.

	Slurp up all the key data. In the future, it might be nice
	to look for KEY foo OUTOFBAND and FAILED indicators. It's
	harmless to ignore them, but ignoring them does make gpg
	complain about "no valid OpenPGP data found". One way to do
	this could be to continue parsing this line-by-line and make
	a temp iobuf for each key. Note that we don't allow the
	import of secret keys from a keyserver. Keyservers should
	never accept or send them but we better protect against rogue
	keyservers. */

	/* For LDAP servers we reset IMPORT_SELF_SIGS_ONLY unless it has
	* been set explicitly. */
	options = (opt.keyserver_options.import_options \| IMPORT_NO_SECKEY);
	if (source && (!strncmp (source, "ldap:", 5)
	\|\| !strncmp (source, "ldaps:", 6))
	&& !opt.flags.expl_import_self_sigs_only)
	options &= ~IMPORT_SELF_SIGS_ONLY;

	screenerarg.desc = desc;
	screenerarg.ndesc = *r_ndesc_used;
	import_keys_es_stream (ctrl, datastream, stats_handle,
	r_fpr, r_fprlen, options,
	keyserver_retrieval_screener, &screenerarg,
	only_fprs? KEYORG_KS : 0,
	source);
	}
	es_fclose (datastream);
	xfree (source);

	return err;
	}


	/* Retrieve a key from a keyserver. The search pattern are in
	(DESC,NDESC). Allowed search modes are keyid, fingerprint, and
	exact searches. OVERRIDE_KEYSERVER gives an optional override
	keyserver. If (R_FPR,R_FPRLEN) are not NULL, they may return the
	fingerprint of a single imported key. If the FLAG bit
	KEYSERVER_IMPORT_FLAG_QUICK is set, dirmngr is advised to use a
	shorter timeout. */
	static gpg_error_t
	keyserver_get (ctrl_t ctrl, KEYDB_SEARCH_DESC *desc, int ndesc,
	struct keyserver_spec *override_keyserver, unsigned int flags,
	unsigned char *r_fpr, size_t r_fprlen)
	{
	gpg_error_t err;
	import_stats_t stats_handle;
	int ndesc_used;
	int any_good = 0;

	stats_handle = import_new_stats_handle();

	for (;;)
	{
	err = keyserver_get_chunk (ctrl, desc, ndesc, &ndesc_used, stats_handle,
	override_keyserver, flags, r_fpr, r_fprlen);
	if (!err)
	any_good = 1;
	if (err \|\| ndesc_used >= ndesc)
	break; /* Error or all processed. */
	/* Prepare for the next chunk. */
	desc += ndesc_used;
	ndesc -= ndesc_used;
	}

	if (any_good)
	import_print_stats (stats_handle);

	import_release_stats_handle (stats_handle);
	return err;
	}


	/* Send all keys specified by KEYSPECS to the configured keyserver. */
	static gpg_error_t
	keyserver_put (ctrl_t ctrl, strlist_t keyspecs)

	{
	gpg_error_t err;
	strlist_t kspec;
	char *ksurl;

	if (!keyspecs)
	return 0; /* Return success if the list is empty. */

	if (gpg_dirmngr_ks_list (ctrl, &ksurl))
	{
	log_error (_("no keyserver known\n"));
	return gpg_error (GPG_ERR_NO_KEYSERVER);
	}

	for (kspec = keyspecs; kspec; kspec = kspec->next)
	{
	void *data;
	size_t datalen;
	kbnode_t keyblock;

	err = export_pubkey_buffer (ctrl, kspec->d,
	opt.keyserver_options.export_options,
	NULL, 0, NULL,
	&keyblock, &data, &datalen);
	if (err)
	log_error (_("skipped \"%s\": %s\n"), kspec->d, gpg_strerror (err));
	else
	{
	if (!opt.quiet)
	log_info (_("sending key %s to %s\n"),
	keystr (keyblock->pkt->pkt.public_key->keyid),
	ksurl?ksurl:"[?]");

	err = gpg_dirmngr_ks_put (ctrl, data, datalen, keyblock);
	release_kbnode (keyblock);
	xfree (data);
	if (err)
	{
	write_status_error ("keyserver_send", err);
	log_error (_("keyserver send failed: %s\n"), gpg_strerror (err));
	}
	}
	}

	xfree (ksurl);

	return err;

	}


	/* Loop over all URLs in STRLIST and fetch the key at that URL. Note
	that the fetch operation ignores the configured keyservers and
	instead directly retrieves the keys. */
	int
	keyserver_fetch (ctrl_t ctrl, strlist_t urilist, int origin)
	{
	gpg_error_t err;
	strlist_t sl;
	estream_t datastream;
	unsigned int save_options = opt.keyserver_options.import_options;
	int any_success = 0;
	gpg_error_t firsterr = 0;

	/* Switch on fast-import, since fetch can handle more than one
	import and we don't want each set to rebuild the trustdb.
	Instead we do it once at the end. */
	opt.keyserver_options.import_options \|= IMPORT_FAST;

	for (sl=urilist; sl; sl=sl->next)
	{
	if (!opt.quiet)
	log_info (_("requesting key from '%s'\n"), sl->d);

	err = gpg_dirmngr_ks_fetch (ctrl, sl->d, &datastream);
	if (!err)
	{
	import_stats_t stats_handle;

	stats_handle = import_new_stats_handle();
	import_keys_es_stream (ctrl, datastream, stats_handle, NULL, NULL,
	opt.keyserver_options.import_options,
	NULL, NULL, origin, sl->d);

	import_print_stats (stats_handle);
	import_release_stats_handle (stats_handle);
	any_success = 1;
	}
	else
	{
	log_info (_("WARNING: unable to fetch URI %s: %s\n"),
	sl->d, gpg_strerror (err));
	if (!firsterr)
	firsterr = err;
	}
	es_fclose (datastream);
	}

	if (!urilist)
	err = gpg_error (GPG_ERR_NO_NAME);
	else if (any_success)
	err = 0;
	else
	err = firsterr;

	opt.keyserver_options.import_options = save_options;

	/* If the original options didn't have fast import, and the trustdb
	is dirty, rebuild. */
	if (!(opt.keyserver_options.import_options&IMPORT_FAST))
	check_or_update_trustdb (ctrl);

	return err;
	}


	/* Import key in a CERT or pointed to by a CERT. In DANE_MODE fetch
	the certificate using the DANE method. */
	int
	keyserver_import_cert (ctrl_t ctrl, const char *name, int dane_mode,
	unsigned char *fpr,size_t fpr_len)
	{
	gpg_error_t err;
	char look,url;
	estream_t key;

	look = xstrdup(name);

	if (!dane_mode)
	{
	char *domain = strrchr (look,'@');
	if (domain)
	*domain='.';
	}

	err = gpg_dirmngr_dns_cert (ctrl, look, dane_mode? NULL : "*",
	&key, fpr, fpr_len, &url);
	if (err)
	;
	else if (key)
	{
	int armor_status=opt.no_armor;
	import_filter_t save_filt;

	/* CERTs and DANE records are always in binary format */
	opt.no_armor=1;
	if (dane_mode)
	{
	save_filt = save_and_clear_import_filter ();
	if (!save_filt)
	err = gpg_error_from_syserror ();
	else
	{
	char *filtstr = es_bsprintf ("keep-uid=mbox = %s", look);
	err = filtstr? 0 : gpg_error_from_syserror ();
	if (!err)
	err = parse_and_set_import_filter (filtstr);
	xfree (filtstr);
	if (!err)
	err = import_keys_es_stream (ctrl, key, NULL, fpr, fpr_len,
	IMPORT_NO_SECKEY,
	NULL, NULL, KEYORG_DANE, NULL);
	restore_import_filter (save_filt);
	}
	}
	else
	{
	err = import_keys_es_stream (ctrl, key, NULL, fpr, fpr_len,
	(opt.keyserver_options.import_options
	\| IMPORT_NO_SECKEY),
	NULL, NULL, 0, NULL);
	}

	opt.no_armor=armor_status;

	es_fclose (key);
	key = NULL;
	}
	else if (*fpr)
	{
	/* We only consider the IPGP type if a fingerprint was provided.
	This lets us select the right key regardless of what a URL
	points to, or get the key from a keyserver. */
	if(url)
	{
	struct keyserver_spec *spec;

	spec = parse_keyserver_uri (url, 1);
	if(spec)
	{
	err = keyserver_import_fprint (ctrl, fpr, fpr_len, spec, 0);
	free_keyserver_spec(spec);
	}
	}
	else if (keyserver_any_configured (ctrl))
	{
	/* If only a fingerprint is provided, try and fetch it from
	the configured keyserver. */

	err = keyserver_import_fprint (ctrl,
	fpr, fpr_len, opt.keyserver, 0);
	}
	else
	log_info(_("no keyserver known\n"));

	/* Give a better string here? "CERT fingerprint for \"%s\"
	found, but no keyserver" " known (use option
	--keyserver)\n" ? */

	}

	xfree(url);
	xfree(look);

	return err;
	}

	/* Import key pointed to by a PKA record. Return the requested
	fingerprint in fpr. */
	gpg_error_t
	keyserver_import_pka (ctrl_t ctrl, const char *name,
	unsigned char *fpr, size_t fpr_len)
	{
	gpg_error_t err;
	char *url;

	err = gpg_dirmngr_get_pka (ctrl, name, fpr, fpr_len, &url);
	if (url && *url && fpr && fpr_len)
	{
	/* An URL is available. Lookup the key. */
	struct keyserver_spec *spec;
	spec = parse_keyserver_uri (url, 1);
	if (spec)
	{
	err = keyserver_import_fprint (ctrl, fpr, fpr_len, spec, 0);
	free_keyserver_spec (spec);
	}
	}
	xfree (url);

	if (err)
	{
	xfree(*fpr);
	*fpr = NULL;
	*fpr_len = 0;
	}

	return err;
	}


	/* Import a key using the Web Key Directory protocol. */
	gpg_error_t
	keyserver_import_wkd (ctrl_t ctrl, const char *name, unsigned int flags,
	unsigned char *fpr, size_t fpr_len)
	{
	gpg_error_t err;
	char *mbox;
	estream_t key;
	char *url = NULL;

	/* We want to work on the mbox. That is what dirmngr will do anyway
	* and we need the mbox for the import filter anyway. */
	mbox = mailbox_from_userid (name);
	if (!mbox)
	{
	err = gpg_error_from_syserror ();
	if (gpg_err_code (err) == GPG_ERR_EINVAL)
	err = gpg_error (GPG_ERR_INV_USER_ID);
	return err;
	}

	err = gpg_dirmngr_wkd_get (ctrl, mbox, flags, &key, &url);
	if (err)
	;
	else if (key)
	{
	int armor_status = opt.no_armor;
	import_filter_t save_filt;

	/* Keys returned via WKD are in binary format. However, we
	* relax that requirement and allow also for armored data. */
	opt.no_armor = 0;
	save_filt = save_and_clear_import_filter ();
	if (!save_filt)
	err = gpg_error_from_syserror ();
	else
	{
	char *filtstr = es_bsprintf ("keep-uid=mbox = %s", mbox);
	err = filtstr? 0 : gpg_error_from_syserror ();
	if (!err)
	err = parse_and_set_import_filter (filtstr);
	xfree (filtstr);
	if (!err)
	err = import_keys_es_stream (ctrl, key, NULL, fpr, fpr_len,
	IMPORT_NO_SECKEY,
	NULL, NULL, KEYORG_WKD, url);

	}

	restore_import_filter (save_filt);
	opt.no_armor = armor_status;

	es_fclose (key);
	key = NULL;
	}

	xfree (url);
	xfree (mbox);
	return err;
	}


	/* Import a key by name using LDAP */
	int
	keyserver_import_ldap (ctrl_t ctrl,
	const char name, unsigned char fpr, size_t fprlen)
	{
	(void)ctrl;
	(void)name;
	(void)fpr;
	(void)fprlen;
	return gpg_error (GPG_ERR_NOT_IMPLEMENTED); /FIXME/
	#if 0
	char *domain;
	struct keyserver_spec *keyserver;
	strlist_t list=NULL;
	int rc,hostlen=1;
	struct srventry *srvlist=NULL;
	int srvcount,i;
	char srvname[MAXDNAME];

	/* Parse out the domain */
	domain=strrchr(name,'@');
	if(!domain)
	return GPG_ERR_GENERAL;

	domain++;

	keyserver=xmalloc_clear(sizeof(struct keyserver_spec));
	keyserver->scheme=xstrdup("ldap");
	keyserver->host=xmalloc(1);
	keyserver->host[0]='\0';

	snprintf(srvname,MAXDNAME,"_pgpkey-ldap._tcp.%s",domain);

	FIXME("network related - move to dirmngr or drop the code");
	srvcount=getsrv(srvname,&srvlist);

	for(i=0;i<srvcount;i++)
	{
	hostlen+=strlen(srvlist[i].target)+1;
	keyserver->host=xrealloc(keyserver->host,hostlen);

	strcat(keyserver->host,srvlist[i].target);

	if(srvlist[i].port!=389)
	{
	char port[7];

	hostlen+=6; /* a colon, plus 5 digits (unsigned 16-bit value) */
	keyserver->host=xrealloc(keyserver->host,hostlen);

	snprintf(port,7,":%u",srvlist[i].port);
	strcat(keyserver->host,port);
	}

	strcat(keyserver->host," ");
	}

	free(srvlist);

	/* If all else fails, do the PGP Universal trick of
	ldap://keys.(domain) */

	hostlen+=5+strlen(domain);
	keyserver->host=xrealloc(keyserver->host,hostlen);
	strcat(keyserver->host,"keys.");
	strcat(keyserver->host,domain);

	append_to_strlist(&list,name);

	rc = gpg_error (GPG_ERR_NOT_IMPLEMENTED); /FIXME/
	/* keyserver_work (ctrl, KS_GETNAME, list, NULL, */
	/* 0, fpr, fpr_len, keyserver); */

	free_strlist(list);

	free_keyserver_spec(keyserver);

	return rc;
	#endif
	}
	diff --git a/po/ca.po b/po/ca.po
	index 398faffe7..9661185a8 100644
	--- a/po/ca.po
	+++ b/po/ca.po
	@@ -1,11616 +1,11627 @@
	# Missatges de gnupg en català.
	# Copyright © 2001, 2002, 2003, 2005 Free Software Foundation, Inc.
	# Carles Sadurní Anguita <sadurni@jazzfree.com>, 2001.
	# Jordi Mallach <jordi@gnu.org>, 2001, 2002, 2003, 2005.
	#
	# Coses (jm):
	# ID d'usuari és masculí? Hi ha una mescla...
	# (ivb: ID == identificador -> masculí)
	# Canviar ID -> ID d'usuari
	# Xifratge vs. Xifrat
	# (ivb: xifratge -> acció, xifrat -> adjectiu)
	# + coses (ivb):
	# - Algunes frases incompletes «x desconegut» -> «x és desconegut».
	# - «algoritme» o «algorisme»? (ambdós són correctes)
	# - digest -> resum
	# - «anell» o «clauer»? (key ring -> clauer)
	# - bug -> error? (del recull)
	# - Crec q uses més «signatura» q «firma»; unifique.
	# - Usar majúscules x ressaltar (com original)?
	# - Hi ha cert desordre en les cometes ;)
	# - Frases índies completades.
	# - Algunes incoherències: error {en la lectura,en llegir,mentre es llegia}
	# - Probablement he clavat la pota en tots els Photo ID :P
	# - Només es maneja amb les mans.
	# - sapigueu -> sapieu? (x coherència)
	msgid ""
	msgstr ""
	"Project-Id-Version: gnupg 1.4.0\n"
	"Report-Msgid-Bugs-To: translations@gnupg.org\n"
	"PO-Revision-Date: 2005-02-04 02:04+0100\n"
	"Last-Translator: Jordi Mallach <jordi@gnu.org>\n"
	"Language-Team: Catalan <ca@dodds.net>\n"
	"Language: ca\n"
	"MIME-Version: 1.0\n"
	"Content-Type: text/plain; charset=UTF-8\n"
	"Content-Transfer-Encoding: 8bit\n"

	#, fuzzy, c-format
	msgid "failed to acquire the pinentry lock: %s\n"
	msgstr "no s'ha pogut emmagatzemar l'empremta digital: %s\n"

	#. TRANSLATORS: These are labels for buttons etc used in
	#. Pinentries. An underscore indicates that the next letter
	#. should be used as an accelerator. Double the underscore for
	#. a literal one. The actual to be translated text starts after
	#. the second vertical bar. Note that gpg-agent has been set to
	#. utf-8 so that the strings are in the expected encoding.
	msgid "\|pinentry-label\|_OK"
	msgstr ""

	msgid "\|pinentry-label\|_Cancel"
	msgstr ""

	msgid "\|pinentry-label\|_Yes"
	msgstr ""

	msgid "\|pinentry-label\|_No"
	msgstr ""

	msgid "\|pinentry-label\|PIN:"
	msgstr ""

	msgid "\|pinentry-label\|_Save in password manager"
	msgstr ""

	#, fuzzy
	#\| msgid "Do you really want to create a sign and encrypt key? "
	msgid "Do you really want to make your passphrase visible on the screen?"
	msgstr "Segur que voleu crear una clau de signatura i xifratge? "

	msgid "\|pinentry-tt\|Make passphrase visible"
	msgstr ""

	#, fuzzy
	#\| msgid "invalid passphrase"
	msgid "\|pinentry-tt\|Hide passphrase"
	msgstr "la contrasenya és invàlida"

	+msgid "Caps Lock is on"
	+msgstr ""
	+
	#. TRANSLATORS: This string is displayed by Pinentry as the label
	#. for generating a passphrase.
	msgid "Suggest"
	msgstr ""

	#. TRANSLATORS: This string is a tooltip, shown by pinentry when
	#. hovering over the generate button. Please use an appropriate
	#. string to describe what this is about. The length of the
	#. tooltip is limited to about 900 characters. If you do not
	#. translate this entry, a default English text (see source)
	#. will be used. The strcmp thingy is there to detect a
	#. non-translated string.
	msgid "pinentry.genpin.tooltip"
	msgstr ""

	msgid "Note: The blanks are not part of the passphrase."
	msgstr ""

	#. TRANSLATORS: This is a text shown by pinentry as title of a dialog
	#. telling the user that the entered new passphrase does not satisfy
	#. the passphrase constraints. Please keep it short.
	#, fuzzy
	msgid "Passphrase Not Allowed"
	msgstr "la contrasenya és massa llarga\n"

	#. TRANSLATORS: This string is displayed by Pinentry as the label
	#. for the quality bar.
	msgid "Quality:"
	msgstr ""

	#. TRANSLATORS: This string is a tooltip, shown by pinentry when
	#. hovering over the quality bar. Please use an appropriate
	#. string to describe what this is about. The length of the
	#. tooltip is limited to about 900 characters. If you do not
	#. translate this entry, a default english text (see source)
	#. will be used.
	msgid "pinentry.qualitybar.tooltip"
	msgstr ""

	msgid ""
	"Please enter your PIN, so that the secret key can be unlocked for this "
	"session"
	msgstr ""

	#, fuzzy
	msgid ""
	"Please enter your passphrase, so that the secret key can be unlocked for "
	"this session"
	msgstr "Introduïu la contrasenya; aquesta ha de ser una frase secreta \n"

	msgid "PIN:"
	msgstr ""

	#, fuzzy
	msgid "Passphrase:"
	msgstr "la contrasenya és errònia"

	msgid "does not match - try again"
	msgstr ""

	#. TRANSLATORS: The string is appended to an error message in
	#. the pinentry. The %s is the actual error message, the
	#. two %d give the current and maximum number of tries.
	#. Do not translate the "SETERROR" keyword.
	#. TRANSLATORS: The string is appended to an error message in
	#. the pinentry. The %s is the actual error message, the
	#. two %d give the current and maximum number of tries.
	#, c-format
	msgid "SETERROR %s (try %d of %d)"
	msgstr ""

	msgid "Repeat:"
	msgstr ""

	#, fuzzy
	msgid "PIN too long"
	msgstr "la línia és massa llarga\n"

	#, fuzzy
	msgid "Passphrase too long"
	msgstr "la contrasenya és massa llarga\n"

	#, fuzzy
	msgid "Invalid characters in PIN"
	msgstr "Hi ha un caràcter invàlid en el camp nom\n"

	msgid "PIN too short"
	msgstr ""

	#, fuzzy
	msgid "Bad PIN"
	msgstr "l'MPI és erroni"

	#, fuzzy
	msgid "Bad Passphrase"
	msgstr "la contrasenya és errònia"

	msgid "Note: Request from the web browser."
	msgstr ""

	msgid "Note: Request from a remote site."
	msgstr ""

	#, fuzzy, c-format
	msgid "error getting serial number of card: %s\n"
	msgstr "error en la creació de la contrasenya: %s\n"

	#, fuzzy
	msgid "Please re-enter this passphrase"
	msgstr "canvia la contrasenya"

	#, fuzzy, c-format
	msgid ""
	"Please enter the passphrase to protect the imported object within the %s "
	"system."
	msgstr "Introduïu la contrasenya; aquesta ha de ser una frase secreta \n"

	msgid ""
	"This key (or subkey) is not protected with a passphrase. Please enter a new "
	"passphrase to export it."
	msgstr ""

	#, fuzzy, c-format
	msgid "ssh keys greater than %d bits are not supported\n"
	msgstr "l'algoritme de protecció %d%s no està suportat\n"

	#, fuzzy, c-format
	#\| msgid "can't create `%s': %s\n"
	msgid "can't create '%s': %s\n"
	msgstr "no s'ha pogut crear «%s»: %s\n"

	#, fuzzy, c-format
	#\| msgid "can't open `%s': %s\n"
	msgid "can't open '%s': %s\n"
	msgstr "no s'ha pogut obrir «%s»: %s\n"

	#, c-format
	msgid "detected card with S/N: %s\n"
	msgstr ""

	#, fuzzy, c-format
	msgid "no authentication key for ssh on card: %s\n"
	msgstr "s'ha produït un error mentre s'escrivia l'anell secret «%s»: %s\n"

	#, fuzzy, c-format
	msgid "no suitable card key found: %s\n"
	msgstr ""
	"no s'ha trobat cap anell secret de escrivible: %s\n"
	"\n"

	#, fuzzy, c-format
	msgid "error getting list of cards: %s\n"
	msgstr "error en crear «%s»: %s\n"

	#, c-format
	msgid ""
	"An ssh process requested the use of key%%0A %s%%0A (%s)%%0ADo you want to "
	"allow this?"
	msgstr ""

	msgid "Allow"
	msgstr ""

	msgid "Deny"
	msgstr ""

	#, fuzzy, c-format
	msgid "Please enter the passphrase for the ssh key%%0A %F%%0A (%c)"
	msgstr "Introduïu la contrasenya; aquesta ha de ser una frase secreta \n"

	#, fuzzy, c-format
	msgid ""
	"Please enter a passphrase to protect the received secret key%%0A %s%%0A "
	"%s%%0Awithin gpg-agent's key storage"
	msgstr "Introduïu la contrasenya; aquesta ha de ser una frase secreta \n"

	#, fuzzy, c-format
	msgid "failed to create stream from socket: %s\n"
	msgstr "%s: no s'ha pogut crear la taula de dispersió: %s\n"

	msgid "Please insert the card with serial number"
	msgstr ""

	msgid "Please remove the current card and insert the one with serial number"
	msgstr ""

	#, fuzzy
	msgid "Admin PIN"
	msgstr "Introduïu el nom d'usuari: "

	#. TRANSLATORS: A PUK is the Personal Unblocking Code
	#. used to unblock a PIN.
	msgid "PUK"
	msgstr ""

	msgid "Reset Code"
	msgstr ""

	msgid "Push ACK button on card/token."
	msgstr ""

	msgid "Use the reader's pinpad for input."
	msgstr ""

	#, fuzzy
	msgid "Repeat this Reset Code"
	msgstr "Repetiu la contrasenya: "

	#, fuzzy
	msgid "Repeat this PUK"
	msgstr "Repetiu la contrasenya: "

	#, fuzzy
	msgid "Repeat this PIN"
	msgstr "Repetiu la contrasenya: "

	#, fuzzy
	msgid "Reset Code not correctly repeated; try again"
	msgstr "la contrasenya no s'ha repetit correctament; torneu a intentar-ho"

	#, fuzzy
	msgid "PUK not correctly repeated; try again"
	msgstr "la contrasenya no s'ha repetit correctament; torneu a intentar-ho"

	#, fuzzy
	msgid "PIN not correctly repeated; try again"
	msgstr "la contrasenya no s'ha repetit correctament; torneu a intentar-ho"

	#, c-format
	msgid "Please enter the PIN%s%s%s to unlock the card"
	msgstr ""

	#, fuzzy, c-format
	msgid "error writing to pipe: %s\n"
	msgstr "error mentre s'escrivia l'anell «%s»: %s\n"

	#, fuzzy
	msgid "Enter new passphrase"
	msgstr "Introduïu la contrasenya\n"

	#, fuzzy
	msgid "Take this one anyway"
	msgstr "Voleu usar de tota manera aquesta clau?"

	#, c-format
	msgid ""
	"You have not entered a passphrase!%0AAn empty passphrase is not allowed."
	msgstr ""

	#, c-format
	msgid ""
	"You have not entered a passphrase - this is in general a bad idea!%0APlease "
	"confirm that you do not want to have any protection on your key."
	msgstr ""

	msgid "Yes, protection is not needed"
	msgstr ""

	#, fuzzy, c-format
	#\| msgid "Name must be at least 5 characters long\n"
	msgid "A passphrase should be at least %u character long."
	msgid_plural "A passphrase should be at least %u characters long."
	msgstr[0] "El nom ha de tenir, si més no, 5 caràcters\n"
	msgstr[1] "El nom ha de tenir, si més no, 5 caràcters\n"

	#, c-format
	msgid "A passphrase should contain at least %u digit or%%0Aspecial character."
	msgid_plural ""
	"A passphrase should contain at least %u digits or%%0Aspecial characters."
	msgstr[0] ""
	msgstr[1] ""

	#, c-format
	msgid "A passphrase may not be a known term or match%%0Acertain pattern."
	msgstr ""

	msgid "Warning: You have entered an insecure passphrase."
	msgstr ""

	#, fuzzy, c-format
	msgid "Please enter the passphrase to%0Aprotect your new key"
	msgstr ""
	"Cal una contrasenya per a protegir la clau secreta.\n"
	"\n"

	#, fuzzy
	msgid "Please enter the new passphrase"
	msgstr "canvia la contrasenya"

	msgid "Options used for startup"
	msgstr ""

	msgid "run in daemon mode (background)"
	msgstr ""

	msgid "run in server mode (foreground)"
	msgstr ""

	#, fuzzy
	#\| msgid "Key is superseded"
	msgid "run in supervised mode"
	msgstr "La clau ha estat substituïda"

	msgid "do not detach from the console"
	msgstr ""

	msgid "sh-style command output"
	msgstr ""

	msgid "csh-style command output"
	msgstr ""

	#, fuzzy
	msgid "\|FILE\|read options from FILE"
	msgstr "\|FITXER\|carrega el mòdul d'extensió especificat"

	msgid "Options controlling the diagnostic output"
	msgstr ""

	# Un dels dos és en la llista d'opcions amb --help. Urgh. jm
	msgid "verbose"
	msgstr "detall"

	msgid "be somewhat more quiet"
	msgstr "una mica més silenciós"

	msgid "\|FILE\|write server mode logs to FILE"
	msgstr ""

	msgid "Options controlling the configuration"
	msgstr ""

	#, fuzzy
	msgid "do not use the SCdaemon"
	msgstr "actualitza la base de dades de confiança"

	msgid "\|PGM\|use PGM as the SCdaemon program"
	msgstr ""

	#, fuzzy
	#\| msgid "\|NAME\|set terminal charset to NAME"
	msgid "\|NAME\|accept some commands via NAME"
	msgstr "\|NOM\|el joc de caràcters serà NOM"

	msgid "ignore requests to change the TTY"
	msgstr ""

	msgid "ignore requests to change the X display"
	msgstr ""

	# Gènere? Nombre? ivb
	# Werner FIXME: please add translator comment saying what is
	# uncompressed so we know the gender. jm
	#, fuzzy
	#\| msgid "not supported"
	msgid "enable ssh support"
	msgstr "no és suportat"

	msgid "\|ALGO\|use ALGO to show ssh fingerprints"
	msgstr ""

	# Gènere? Nombre? ivb
	# Werner FIXME: please add translator comment saying what is
	# uncompressed so we know the gender. jm
	#, fuzzy
	#\| msgid "not supported"
	msgid "enable putty support"
	msgstr "no és suportat"

	msgid "Options controlling the security"
	msgstr ""

	msgid "\|N\|expire cached PINs after N seconds"
	msgstr ""

	msgid "\|N\|expire SSH keys after N seconds"
	msgstr ""

	msgid "\|N\|set maximum PIN cache lifetime to N seconds"
	msgstr ""

	msgid "\|N\|set maximum SSH key lifetime to N seconds"
	msgstr ""

	msgid "do not use the PIN cache when signing"
	msgstr ""

	#, fuzzy
	msgid "disallow the use of an external password cache"
	msgstr "error en la creació de la contrasenya: %s\n"

	msgid "disallow clients to mark keys as \"trusted\""
	msgstr ""

	#, fuzzy
	msgid "allow presetting passphrase"
	msgstr "error en la creació de la contrasenya: %s\n"

	msgid "Options enforcing a passphrase policy"
	msgstr ""

	msgid "do not allow bypassing the passphrase policy"
	msgstr ""

	msgid "\|N\|set minimal required length for new passphrases to N"
	msgstr ""

	msgid "\|N\|require at least N non-alpha characters for a new passphrase"
	msgstr ""

	msgid "\|FILE\|check new passphrases against pattern in FILE"
	msgstr ""

	#, fuzzy
	msgid "\|N\|expire the passphrase after N days"
	msgstr "\|N\|usa el mode de contrasenya especificat"

	#, fuzzy
	msgid "do not allow the reuse of old passphrases"
	msgstr "error en la creació de la contrasenya: %s\n"

	msgid "Options controlling the PIN-Entry"
	msgstr ""

	#, fuzzy
	#\| msgid "use the gpg-agent"
	msgid "never use the PIN-entry"
	msgstr "utilitza el gpg-agent"

	msgid "disallow caller to override the pinentry"
	msgstr ""

	msgid "let PIN-Entry grab keyboard and mouse"
	msgstr ""

	msgid "\|PGM\|use PGM as the PIN-Entry program"
	msgstr ""

	msgid "\|N\|set the Pinentry timeout to N seconds"
	msgstr ""

	msgid "allow passphrase to be prompted through Emacs"
	msgstr ""

	#. TRANSLATORS: @EMAIL@ will get replaced by the actual bug
	#. reporting address. This is so that we can change the
	#. reporting address without breaking the translations.
	#, fuzzy
	msgid "Please report bugs to <@EMAIL@>.\n"
	msgstr "Si us plau, informeu sobre els errors a <gnupg-bugs@gnu.org>.\n"

	#, fuzzy
	msgid "Usage: @GPG_AGENT@ [options] (-h for help)"
	msgstr "Forma d'ús: gpg [opcions] [fitxers] (-h per a veure l'ajuda)"

	msgid ""
	"Syntax: @GPG_AGENT@ [options] [command [args]]\n"
	"Secret key management for @GNUPG@\n"
	msgstr ""

	#, c-format
	msgid "invalid debug-level '%s' given\n"
	msgstr ""

	#, c-format
	msgid "selected digest algorithm is invalid\n"
	msgstr "l'algorisme de resum seleccionat no és vàlid\n"

	#, fuzzy, c-format
	#\| msgid "reading options from `%s'\n"
	msgid "reading options from '%s'\n"
	msgstr "s'estan llegint opcions de «%s»\n"

	#, fuzzy, c-format
	#\| msgid "WARNING: \"%s\" is a deprecated option\n"
	msgid "Note: '%s' is not considered an option\n"
	msgstr "AVÍS: %s és una opció desaconsellada.\n"

	#, fuzzy, c-format
	msgid "can't create socket: %s\n"
	msgstr "no s'ha pogut crear «%s»: %s\n"

	#, fuzzy, c-format
	msgid "socket name '%s' is too long\n"
	msgstr "Certificat de revocació vàlid"

	#, c-format
	msgid "trying to steal socket from running %s\n"
	msgstr ""

	#, fuzzy, c-format
	msgid "a gpg-agent is already running - not starting a new one\n"
	msgstr "gpg-agent no està disponible en aquesta sessió\n"

	#, fuzzy, c-format
	msgid "error getting nonce for the socket\n"
	msgstr "error en crear «%s»: %s\n"

	#, fuzzy, c-format
	msgid "error binding socket to '%s': %s\n"
	msgstr "error mentre s'enviava a «%s»: %s\n"

	#, fuzzy, c-format
	msgid "can't set permissions of '%s': %s\n"
	msgstr "AVÍS: els permissos són insegurs en %s «%s»\n"

	#, fuzzy, c-format
	msgid "listening on socket '%s'\n"
	msgstr "s'està escrivint la clau secreta a «%s»\n"

	#, fuzzy, c-format
	#\| msgid "can't create directory `%s': %s\n"
	msgid "can't create directory '%s': %s\n"
	msgstr "no es pot crear el directori «%s»: %s\n"

	#, fuzzy, c-format
	msgid "directory '%s' created\n"
	msgstr "%s: s'ha creat el directori\n"

	#, fuzzy, c-format
	msgid "stat() failed for '%s': %s\n"
	msgstr "base de dades de confiança: ha fallat la lectura (n=%d): %s\n"

	#, fuzzy, c-format
	msgid "can't use '%s' as home directory\n"
	msgstr "%s: no s'ha pogut crear el directori: %s\n"

	#, fuzzy, c-format
	msgid "error reading nonce on fd %d: %s\n"
	msgstr "error en la lectura de «%s»: %s\n"

	#, c-format
	msgid "handler 0x%lx for fd %d started\n"
	msgstr ""

	#, c-format
	msgid "handler 0x%lx for fd %d terminated\n"
	msgstr ""

	#, c-format
	msgid "ssh handler 0x%lx for fd %d started\n"
	msgstr ""

	#, c-format
	msgid "ssh handler 0x%lx for fd %d terminated\n"
	msgstr ""

	#, fuzzy, c-format
	msgid "npth_pselect failed: %s - waiting 1s\n"
	msgstr "ha fallat l'actualització de la clau secreta: %s\n"

	#, fuzzy, c-format
	msgid "%s %s stopped\n"
	msgstr "\t%lu claus es descarta\n"

	#, fuzzy, c-format
	msgid "no gpg-agent running in this session\n"
	msgstr "gpg-agent no està disponible en aquesta sessió\n"

	#, fuzzy
	msgid ""
	"@Options:\n"
	" "
	msgstr ""
	"@\n"
	"Opcions:\n"
	" "

	#, fuzzy
	msgid "Usage: gpg-preset-passphrase [options] KEYGRIP (-h for help)\n"
	msgstr "Forma d'ús: gpg [opcions] [fitxers] (-h per a veure l'ajuda)"

	msgid ""
	"Syntax: gpg-preset-passphrase [options] KEYGRIP\n"
	"Password cache maintenance\n"
	msgstr ""

	msgid ""
	"@Commands:\n"
	" "
	msgstr ""
	"@Ordres:\n"
	" "

	msgid ""
	"@\n"
	"Options:\n"
	" "
	msgstr ""
	"@\n"
	"Opcions:\n"
	" "

	#, fuzzy
	msgid "Usage: gpg-protect-tool [options] (-h for help)\n"
	msgstr "Forma d'ús: gpg [opcions] [fitxers] (-h per a veure l'ajuda)"

	msgid ""
	"Syntax: gpg-protect-tool [options] [args]\n"
	"Secret key maintenance tool\n"
	msgstr ""

	#, fuzzy
	msgid "Please enter the passphrase to unprotect the PKCS#12 object."
	msgstr "Introduïu la contrasenya; aquesta ha de ser una frase secreta \n"

	#, fuzzy
	msgid "Please enter the passphrase to protect the new PKCS#12 object."
	msgstr "Introduïu la contrasenya; aquesta ha de ser una frase secreta \n"

	msgid ""
	"Please enter the passphrase to protect the imported object within the GnuPG "
	"system."
	msgstr ""

	#, fuzzy
	msgid ""
	"Please enter the passphrase or the PIN\n"
	"needed to complete this operation."
	msgstr "Introduïu la contrasenya; aquesta ha de ser una frase secreta \n"

	#, fuzzy, c-format
	msgid "cancelled\n"
	msgstr "Cancel·la"

	#, fuzzy, c-format
	msgid "error while asking for the passphrase: %s\n"
	msgstr "error en la creació de la contrasenya: %s\n"

	#, fuzzy, c-format
	msgid "error opening '%s': %s\n"
	msgstr "error en la lectura de «%s»: %s\n"

	#, fuzzy, c-format
	msgid "file '%s', line %d: %s\n"
	msgstr "fitxer d'opcions «%s»: %s\n"

	#, fuzzy, c-format
	msgid "statement \"%s\" ignored in '%s', line %d\n"
	msgstr "error de lectura: %s\n"

	# Parts? Peces? ivb
	#, fuzzy, c-format
	msgid "system trustlist '%s' not available\n"
	msgstr "parts de la clau secreta no estan disponbles\n"

	#, fuzzy, c-format
	msgid "bad fingerprint in '%s', line %d\n"
	msgstr "error de lectura: %s\n"

	#, fuzzy, c-format
	msgid "invalid keyflag in '%s', line %d\n"
	msgstr "error: l'empremta digital és invàlida\n"

	#, fuzzy, c-format
	msgid "error reading '%s', line %d: %s\n"
	msgstr "error en la lectura de «%s»: %s\n"

	#, c-format
	msgid "error reading list of trusted root certificates\n"
	msgstr ""

	#. TRANSLATORS: This prompt is shown by the Pinentry
	#. and has one special property: A "%%0A" is used by
	#. Pinentry to insert a line break. The double
	#. percent sign is actually needed because it is also
	#. a printf format string. If you need to insert a
	#. plain % sign, you need to encode it as "%%25". The
	#. "%s" gets replaced by the name as stored in the
	#. certificate.
	#, c-format
	msgid ""
	"Do you ultimately trust%%0A \"%s\"%%0Ato correctly certify user "
	"certificates?"
	msgstr ""

	#, fuzzy
	msgid "Yes"
	msgstr "sí\|si"

	msgid "No"
	msgstr ""

	#. TRANSLATORS: This prompt is shown by the Pinentry and has
	#. one special property: A "%%0A" is used by Pinentry to
	#. insert a line break. The double percent sign is actually
	#. needed because it is also a printf format string. If you
	#. need to insert a plain % sign, you need to encode it as
	#. "%%25". The second "%s" gets replaced by a hexdecimal
	#. fingerprint string whereas the first one receives the name
	#. as stored in the certificate.
	#, c-format
	msgid ""
	"Please verify that the certificate identified as:%%0A \"%s\"%%0Ahas the "
	"fingerprint:%%0A %s"
	msgstr ""

	#. TRANSLATORS: "Correct" is the label of a button and intended
	#. to be hit if the fingerprint matches the one of the CA. The
	#. other button is "the default "Cancel" of the Pinentry.
	msgid "Correct"
	msgstr ""

	msgid "Wrong"
	msgstr ""

	#, c-format
	msgid "Note: This passphrase has never been changed.%0APlease change it now."
	msgstr ""

	#, c-format
	msgid ""
	"This passphrase has not been changed%%0Asince %.4s-%.2s-%.2s. Please change "
	"it now."
	msgstr ""

	#, fuzzy
	msgid "Change passphrase"
	msgstr "canvia la contrasenya"

	msgid "I'll change it later"
	msgstr ""

	#, fuzzy, c-format
	msgid ""
	-"Do you really want to delete the key identified by keygrip%%0A %s%%0A %%C"
	-"%%0A?"
	+"Do you really want to delete the key identified by keygrip%%0A %s%%0A "
	+"%%C%%0A?"
	msgstr "Realment voleu eliminar les claus seleccionades? "

	#, fuzzy
	msgid "Delete key"
	msgstr "activa una clau"

	msgid ""
	"Warning: This key is also listed for use with SSH!\n"
	"Deleting the key might remove your ability to access remote machines."
	msgstr ""

	#, c-format
	msgid "DSA requires the hash length to be a multiple of 8 bits\n"
	msgstr ""

	#, c-format
	msgid "%s key uses an unsafe (%u bit) hash\n"
	msgstr ""

	#, c-format
	msgid "a %zu bit hash is not valid for a %u bit %s key\n"
	msgstr ""

	#, c-format
	msgid "checking created signature failed: %s\n"
	msgstr "no s'ha pogut comprovar la signatura creada: %s\n"

	# Parts? Peces? ivb
	#, c-format
	msgid "secret key parts are not available\n"
	msgstr "parts de la clau secreta no estan disponbles\n"

	#, fuzzy, c-format
	#\| msgid "protection algorithm %d%s is not supported\n"
	msgid "public key algorithm %d (%s) is not supported\n"
	msgstr "l'algoritme de protecció %d%s no està suportat\n"

	#, fuzzy, c-format
	#\| msgid "protection algorithm %d%s is not supported\n"
	msgid "protection algorithm %d (%s) is not supported\n"
	msgstr "l'algoritme de protecció %d%s no està suportat\n"

	#, fuzzy, c-format
	#\| msgid "protection algorithm %d%s is not supported\n"
	msgid "protection hash algorithm %d (%s) is not supported\n"
	msgstr "l'algoritme de protecció %d%s no està suportat\n"

	#, fuzzy, c-format
	msgid "error creating a pipe: %s\n"
	msgstr "error en la creació de la contrasenya: %s\n"

	#, fuzzy, c-format
	msgid "error creating a stream for a pipe: %s\n"
	msgstr "error en la creació de la contrasenya: %s\n"

	#, fuzzy, c-format
	msgid "error forking process: %s\n"
	msgstr "error en la lectura de «%s»: %s\n"

	#, c-format
	msgid "waiting for process %d to terminate failed: %s\n"
	msgstr ""

	#, fuzzy, c-format
	msgid "error running '%s': probably not installed\n"
	msgstr "error en la lectura de «%s»: %s\n"

	#, fuzzy, c-format
	msgid "error running '%s': exit status %d\n"
	msgstr "error en la lectura de «%s»: %s\n"

	#, fuzzy, c-format
	msgid "error running '%s': terminated\n"
	msgstr "error en la lectura de «%s»: %s\n"

	#, fuzzy, c-format
	msgid "waiting for processes to terminate failed: %s\n"
	msgstr "ha fallat l'actualització: %s\n"

	#, fuzzy, c-format
	msgid "error getting exit code of process %d: %s\n"
	msgstr "s'ha produït un error mentre s'escrivia l'anell secret «%s»: %s\n"

	#, fuzzy, c-format
	#\| msgid "can't connect to `%s': %s\n"
	msgid "can't connect to '%s': %s\n"
	msgstr "no s'ha pogut connectar amb «%s»: %s\n"

	#, fuzzy, c-format
	msgid "problem setting the gpg-agent options\n"
	msgstr "hi ha un problema amb l'agent: l'agent ha tornat 0x%lx\n"

	# bolcats de memòria? ivb
	#, c-format
	msgid "can't disable core dumps: %s\n"
	msgstr "no s'han pogut desactivar els bolcats de memòria: %s\n"

	# Indi. ivb
	#, fuzzy, c-format
	msgid "Warning: unsafe ownership on %s \"%s\"\n"
	msgstr "AVÍS: el propietari és insegur en %s «%s»\n"

	#, fuzzy, c-format
	msgid "Warning: unsafe permissions on %s \"%s\"\n"
	msgstr "AVÍS: els permissos són insegurs en %s «%s»\n"

	#, fuzzy, c-format
	msgid "waiting for file '%s' to become accessible ...\n"
	msgstr "ha fallat l'actualització: %s\n"

	#, fuzzy, c-format
	msgid "renaming '%s' to '%s' failed: %s\n"
	msgstr "no s'ha pogut crear l'armadura: %s\n"

	#. TRANSLATORS: See doc/TRANSLATE about this string.
	msgid "yes"
	msgstr "sí\|si"

	msgid "yY"
	msgstr "sS"

	#. TRANSLATORS: See doc/TRANSLATE about this string.
	msgid "no"
	msgstr "no"

	msgid "nN"
	msgstr "nN"

	#. TRANSLATORS: See doc/TRANSLATE about this string.
	msgid "quit"
	msgstr "ix"

	# «xX»? ivb
	msgid "qQ"
	msgstr "xX"

	#. TRANSLATORS: See doc/TRANSLATE about this string.
	msgid "okay\|okay"
	msgstr ""

	#. TRANSLATORS: See doc/TRANSLATE about this string.
	msgid "cancel\|cancel"
	msgstr ""

	msgid "oO"
	msgstr ""

	#, fuzzy
	msgid "cC"
	msgstr "c"

	#, c-format
	msgid "out of core in secure memory while allocating %lu bytes"
	msgstr ""

	#, c-format
	msgid "out of core while allocating %lu bytes"
	msgstr ""

	#, fuzzy, c-format
	msgid "error allocating enough memory: %s\n"
	msgstr "error en crear l'anell «%s»: %s\n"

	#, c-format
	msgid "%s:%u: obsolete option \"%s\" - it has no effect\n"
	msgstr ""

	#, fuzzy, c-format
	msgid "WARNING: \"%s%s\" is an obsolete option - it has no effect\n"
	msgstr "AVÍS: %s és una opció desaconsellada.\n"

	#, c-format
	msgid "unknown debug flag '%s' ignored\n"
	msgstr ""

	#, fuzzy, c-format
	msgid "waiting for the %s to come up ... (%ds)\n"
	msgstr "ha fallat l'actualització: %s\n"

	# Destès? ivb
	# Desatès, sí. jm
	#, fuzzy, c-format
	msgid "connection to %s established\n"
	msgstr "no es pot fet això en mode desatès\n"

	#, c-format
	msgid "no running gpg-agent - starting '%s'\n"
	msgstr ""

	# Destès? ivb
	# Desatès, sí. jm
	#, fuzzy, c-format
	msgid "connection to agent is in restricted mode\n"
	msgstr "no es pot fet això en mode desatès\n"

	#, c-format
	msgid "no running Dirmngr - starting '%s'\n"
	msgstr ""

	#. TRANSLATORS: Copy the prefix between the vertical bars
	#. verbatim. It will not be printed.
	msgid "\|audit-log-result\|Good"
	msgstr ""

	msgid "\|audit-log-result\|Bad"
	msgstr ""

	msgid "\|audit-log-result\|Not supported"
	msgstr ""

	#, fuzzy
	msgid "\|audit-log-result\|No certificate"
	msgstr "Certificat correcte"

	#, fuzzy
	msgid "\|audit-log-result\|Not enabled"
	msgstr "Certificat correcte"

	msgid "\|audit-log-result\|Error"
	msgstr ""

	#, fuzzy
	msgid "\|audit-log-result\|Not used"
	msgstr "Certificat correcte"

	#, fuzzy
	msgid "\|audit-log-result\|Okay"
	msgstr "Certificat correcte"

	#, fuzzy
	msgid "\|audit-log-result\|Skipped"
	msgstr "Certificat correcte"

	#, fuzzy
	msgid "\|audit-log-result\|Some"
	msgstr "Certificat correcte"

	#, fuzzy
	msgid "Certificate chain available"
	msgstr "Certificat de revocació vàlid"

	#, fuzzy
	msgid "root certificate missing"
	msgstr ""
	"No s'han trobat certificats amb confiança no definida.\n"
	"\n"

	msgid "Data encryption succeeded"
	msgstr ""

	#, fuzzy
	msgid "Data available"
	msgstr "La clau és disponible en: "

	# Fitxer indi fins final. Hau! ivb
	# Grrr. Com em tracten els esclaus ja... jm
	#, fuzzy
	msgid "Session key created"
	msgstr "%s: s'ha creat l'anell\n"

	#, fuzzy, c-format
	msgid "algorithm: %s"
	msgstr "armadura: %s\n"

	# Suportats? ivb
	# A Softcatalà diuen molt «implementat». jm
	# Precissament acabem de parlar d'«implementat a la llista del GNOME
	# i s'ha dit que és erroni, igual que «suportat» :) Les alternatives
	# encara no m'agraden massa... jm
	#, fuzzy, c-format
	msgid "unsupported algorithm: %s"
	msgstr ""
	"\n"
	"Algoritmes suportats:\n"

	# Gènere? Nombre? ivb
	# Werner FIXME: please add translator comment saying what is
	# uncompressed so we know the gender. jm
	#, fuzzy
	msgid "seems to be not encrypted"
	msgstr "no és xifrat"

	msgid "Number of recipients"
	msgstr ""

	#, c-format
	msgid "Recipient %d"
	msgstr ""

	msgid "Data signing succeeded"
	msgstr ""

	#, fuzzy, c-format
	msgid "data hash algorithm: %s"
	msgstr "l'algoritme de dispersió és invàlid «%s»\n"

	#, fuzzy, c-format
	msgid "Signer %d"
	msgstr "Aquesta signatura va caducar el %s\n"

	#, fuzzy, c-format
	msgid "attr hash algorithm: %s"
	msgstr "l'algoritme de dispersió és invàlid «%s»\n"

	msgid "Data decryption succeeded"
	msgstr ""

	#, fuzzy
	msgid "Encryption algorithm supported"
	msgstr "l'algoritme de protecció %d%s no està suportat\n"

	#, fuzzy
	msgid "Data verification succeeded"
	msgstr "s'ha eliminat la verificació de signatura\n"

	#, fuzzy
	msgid "Signature available"
	msgstr "Aquesta signatura va caducar el %s\n"

	#, fuzzy
	msgid "Parsing data succeeded"
	msgstr "Signatura correcta de \""

	#, fuzzy, c-format
	msgid "bad data hash algorithm: %s"
	msgstr "l'algoritme de dispersió és invàlid «%s»\n"

	#, fuzzy, c-format
	msgid "Signature %d"
	msgstr "Aquesta signatura va caducar el %s\n"

	#, fuzzy
	msgid "Certificate chain valid"
	msgstr "Certificat de revocació vàlid"

	#, fuzzy
	msgid "Root certificate trustworthy"
	msgstr ""
	"No s'han trobat certificats amb confiança no definida.\n"
	"\n"

	#, fuzzy
	msgid "no CRL found for certificate"
	msgstr "Certificat correcte"

	#, fuzzy
	msgid "the available CRL is too old"
	msgstr "La clau és disponible en: "

	#, fuzzy
	msgid "CRL/OCSP check of certificates"
	msgstr "Certificat correcte"

	#, fuzzy
	msgid "Included certificates"
	msgstr "Certificat invàlid"

	msgid "No audit log entries."
	msgstr ""

	#, fuzzy
	msgid "Unknown operation"
	msgstr "la versió és desconeguda"

	msgid "Gpg-Agent usable"
	msgstr ""

	msgid "Dirmngr usable"
	msgstr ""

	#, fuzzy, c-format
	msgid "No help available for '%s'."
	msgstr "No hi ha ajuda disponible per a `%s'"

	#, fuzzy
	msgid "ignoring garbage line"
	msgstr "error en l'última línia\n"

	#, fuzzy
	msgid "[none]"
	msgstr "[no establert]"

	#, fuzzy, c-format
	msgid "invalid radix64 character %02x skipped\n"
	msgstr "el caràcter radix64 %02x invàlid s'ha omés\n"

	#, c-format
	msgid "Sorry, we are in batchmode - can't get input\n"
	msgstr ""

	#, c-format
	msgid "Sorry, no terminal at all requested - can't get input\n"
	msgstr ""

	#, c-format
	msgid "too many errors; giving up\n"
	msgstr ""

	#, c-format
	msgid "Control-D detected\n"
	msgstr ""

	msgid "argument not expected"
	msgstr ""

	#, fuzzy
	msgid "read error"
	msgstr "error de lectura"

	#, fuzzy
	msgid "keyword too long"
	msgstr "la línia és massa llarga\n"

	#, fuzzy
	msgid "missing argument"
	msgstr "l'argument és invàlid"

	#, fuzzy
	#\| msgid "invalid armor"
	msgid "invalid argument"
	msgstr "l'armadura és invàlida"

	#, fuzzy
	msgid "invalid command"
	msgstr "les ordres entren en conflicte\n"

	#, fuzzy
	msgid "invalid alias definition"
	msgstr "opcions d'importació no vàlides\n"

	msgid "permission error"
	msgstr ""

	# Gènere? Nombre? Passat, futur? ivb
	# Probablement és una clau, femení. jm
	# Werner FIXME: please add translator comment saying what is
	# uncompressed so we know the gender. jm
	#, fuzzy
	msgid "out of core"
	msgstr "no forçat"

	#, fuzzy
	msgid "invalid meta command"
	msgstr "les ordres entren en conflicte\n"

	#, fuzzy
	msgid "unknown meta command"
	msgstr "el destinatari predeterminat és desconegut «%s»\n"

	#, fuzzy
	#\| msgid "unexpected data"
	msgid "unexpected meta command"
	msgstr "dades inesperades"

	#, fuzzy
	msgid "invalid option"
	msgstr "opcions d'importació no vàlides\n"

	#, c-format
	msgid "missing argument for option \"%.50s\"\n"
	msgstr ""

	#, fuzzy, c-format
	msgid "invalid argument for option \"%.50s\"\n"
	msgstr "opcions d'importació no vàlides\n"

	#, c-format
	msgid "option \"%.50s\" does not expect an argument\n"
	msgstr ""

	#, fuzzy, c-format
	msgid "invalid command \"%.50s\"\n"
	msgstr "L'ordre no és vàlida (proveu «help»)\n"

	#, c-format
	msgid "option \"%.50s\" is ambiguous\n"
	msgstr ""

	#, c-format
	msgid "command \"%.50s\" is ambiguous\n"
	msgstr ""

	#, fuzzy, c-format
	msgid "invalid option \"%.50s\"\n"
	msgstr "opcions d'importació no vàlides\n"

	#, fuzzy, c-format
	#\| msgid "NOTE: no default option file `%s'\n"
	msgid "Note: no default option file '%s'\n"
	msgstr "NOTA: no existeix el fitxer d'opcions predeterminades «%s»\n"

	#, fuzzy, c-format
	#\| msgid "option file `%s': %s\n"
	msgid "option file '%s': %s\n"
	msgstr "fitxer d'opcions «%s»: %s\n"

	#, c-format
	msgid "Note: ignoring option \"--%s\" due to global config\n"
	msgstr ""

	#, fuzzy, c-format
	msgid "conversion from '%s' to '%s' not available\n"
	msgstr "no s'ha pogut crear l'armadura: %s\n"

	#, fuzzy, c-format
	msgid "iconv_open failed: %s\n"
	msgstr "no es pot obrir el fitxer: %s\n"

	#, fuzzy, c-format
	msgid "conversion from '%s' to '%s' failed: %s\n"
	msgstr "no s'ha pogut crear l'armadura: %s\n"

	#, fuzzy, c-format
	msgid "failed to create temporary file '%s': %s\n"
	msgstr "no es pot crear el directori «%s»: %s\n"

	#, fuzzy, c-format
	msgid "error writing to '%s': %s\n"
	msgstr "error mentre s'escrivia l'anell «%s»: %s\n"

	#, c-format
	msgid "removing stale lockfile (created by %d)\n"
	msgstr ""

	#, fuzzy, c-format
	msgid "waiting for lock (held by %d%s) %s...\n"
	msgstr "s'està escrivint la clau secreta a «%s»\n"

	msgid "(deadlock?) "
	msgstr ""

	#, fuzzy, c-format
	msgid "lock '%s' not made: %s\n"
	msgstr "no s'ha trobat la clau pública %08lX: %s\n"

	#, fuzzy, c-format
	msgid "waiting for lock %s...\n"
	msgstr "s'està escrivint la clau secreta a «%s»\n"

	#, c-format
	msgid "%s is too old (need %s, have %s)\n"
	msgstr ""

	#, c-format
	msgid "armor: %s\n"
	msgstr "armadura: %s\n"

	#, c-format
	msgid "invalid armor header: "
	msgstr "la capçalera d'armadura és invàlida: "

	#, c-format
	msgid "armor header: "
	msgstr "capçalera d'armadura: "

	#, c-format
	msgid "invalid clearsig header\n"
	msgstr "la capçalera de signatura clara és invàlida\n"

	#, fuzzy, c-format
	msgid "unknown armor header: "
	msgstr "capçalera d'armadura: "

	# És un missatge d'error? ivb
	# «Anidada» és un castellanisme. Niuades? Imbricades (SC)?? ivb
	#, c-format
	msgid "nested clear text signatures\n"
	msgstr "signatures en text pla imbricades\n"

	# FIXME: un-indiar. jm
	#, fuzzy, c-format
	msgid "unexpected armor: "
	msgstr "armadura inesperada:"

	#, c-format
	msgid "invalid dash escaped line: "
	msgstr "la línia escapada amb guió és invàlida: "

	#, fuzzy, c-format
	msgid "invalid radix64 character %02X skipped\n"
	msgstr "el caràcter radix64 %02x invàlid s'ha omés\n"

	#, c-format
	msgid "premature eof (no CRC)\n"
	msgstr "fi de fitxer prematur (no CRC)\n"

	#, c-format
	msgid "premature eof (in CRC)\n"
	msgstr "fi de fitxer prematur (en CRC)\n"

	#, c-format
	msgid "malformed CRC\n"
	msgstr "CRC malformat\n"

	#, fuzzy, c-format
	msgid "CRC error; %06lX - %06lX\n"
	msgstr "error de CRC; %06lx - %06lx\n"

	#, fuzzy, c-format
	msgid "premature eof (in trailer)\n"
	msgstr "fí de fitxer prematur (al final)\n"

	#, c-format
	msgid "error in trailer line\n"
	msgstr "error en l'última línia\n"

	#, c-format
	msgid "no valid OpenPGP data found.\n"
	msgstr "no s'han trobat dades OpenPGP vàlides.\n"

	#, c-format
	msgid "invalid armor: line longer than %d characters\n"
	msgstr "l'armadura és invàlida: la línia és més llarga que %d caràcters\n"

	#, c-format
	msgid ""
	"quoted printable character in armor - probably a buggy MTA has been used\n"
	msgstr ""
	"hi ha un caràcter «quoted printable» en l'armadura - probablement s'ha "
	"utilitzat un MTA amb errors\n"

	#, fuzzy, c-format
	#\| msgid "not human readable"
	msgid "[ not human readable (%zu bytes: %s%s) ]"
	msgstr "no llegible per humans"

	#, c-format
	msgid ""
	"a notation name must have only printable characters or spaces, and end with "
	"an '='\n"
	msgstr ""
	"un nom de notació només pot tenir caràcters imprimibles o espais i acabar "
	"amb el signe «=»\n"

	#, c-format
	msgid "a user notation name must contain the '@' character\n"
	msgstr "un nom de notació d'usuari no pot contenir el caràcter «@»\n"

	#, fuzzy, c-format
	msgid "a notation name must not contain more than one '@' character\n"
	msgstr "un nom de notació d'usuari no pot contenir el caràcter «@»\n"

	#, c-format
	msgid "a notation value must not use any control characters\n"
	msgstr "un valor de notació no pot utilitzar cap caràcter de control\n"

	#, fuzzy, c-format
	msgid "a notation name may not contain an '=' character\n"
	msgstr "un nom de notació d'usuari no pot contenir el caràcter «@»\n"

	#, fuzzy, c-format
	#\| msgid ""
	#\| "a notation name must have only printable characters or spaces, and end "
	#\| "with an '='\n"
	msgid "a notation name must have only printable characters or spaces\n"
	msgstr ""
	"un nom de notació només pot tenir caràcters imprimibles o espais i acabar "
	"amb el signe «=»\n"

	#, c-format
	msgid "WARNING: invalid notation data found\n"
	msgstr "AVÍS: s'hi han trobat dades de notació invàlides\n"

	#, fuzzy, c-format
	msgid "failed to proxy %s inquiry to client\n"
	msgstr "no s'ha pogut posar «%s» en la base de dades de confiança - %s\n"

	msgid "Enter passphrase: "
	msgstr "Introduïu la contrasenya: "

	#, fuzzy, c-format
	#\| msgid "error creating keyring `%s': %s\n"
	msgid "error getting version from '%s': %s\n"
	msgstr "error en crear l'anell «%s»: %s\n"

	#, c-format
	msgid "server '%s' is older than us (%s < %s)"
	msgstr ""

	# FIXME: preferència? jm
	# Ho discutírem en la llista, segur. Deu ser als arxius. ivb
	#, fuzzy, c-format
	#\| msgid "WARNING: %s overrides %s\n"
	msgid "WARNING: %s\n"
	msgstr "AVÍS: %s té preferència sobre %s\n"

	#, c-format
	msgid "Note: Outdated servers may lack important security fixes.\n"
	msgstr ""

	#, fuzzy, c-format
	#\| msgid "Please use the command \"toggle\" first.\n"
	msgid "Note: Use the command \"%s\" to restart them.\n"
	msgstr "Useu l'ordre «toggle» abans.\n"

	#, fuzzy, c-format
	#\| msgid "%s does not yet work with %s\n"
	msgid "%s is not compliant with %s mode\n"
	msgstr "%s encara no funciona amb %s\n"

	#, fuzzy, c-format
	msgid "no dirmngr running in this session\n"
	msgstr "gpg-agent no està disponible en aquesta sessió\n"

	#, fuzzy, c-format
	#\| msgid "you may not use %s while in %s mode\n"
	msgid "keyserver option \"%s\" may not be used in %s mode\n"
	msgstr "no podeu usar %s mentre esteu en mode %s\n"

	msgid "WKD uses a cached result"
	msgstr ""

	msgid "Tor is not running"
	msgstr ""

	#, fuzzy
	msgid "Tor is not properly configured"
	msgstr "error: l'empremta digital és invàlida\n"

	#, fuzzy
	msgid "DNS is not properly configured"
	msgstr "error: l'empremta digital és invàlida\n"

	msgid "unacceptable HTTP redirect from server"
	msgstr ""

	msgid "unacceptable HTTP redirect from server was cleaned up"
	msgstr ""

	#, fuzzy
	#\| msgid "generate a revocation certificate"
	msgid "server uses an invalid certificate"
	msgstr "genera un certificat de revocació"

	#, fuzzy, c-format
	#\| msgid "armor: %s\n"
	msgid "Note: %s\n"
	msgstr "armadura: %s\n"

	#, fuzzy, c-format
	msgid "OpenPGP card not available: %s\n"
	msgstr "la clau secreta no està disponible"

	#, c-format
	msgid "OpenPGP card no. %s detected\n"
	msgstr ""

	# Destès? ivb
	# Desatès, sí. jm
	#, fuzzy, c-format
	msgid "can't do this in batch mode\n"
	msgstr "no es pot fet això en mode desatès\n"

	#, fuzzy, c-format
	msgid "This command is only available for version 2 cards\n"
	msgstr "Aquesta ordre no està permesa mentre s'està en mode %s.\n"

	# Parts? Peces? ivb
	#, fuzzy, c-format
	msgid "Reset Code not or not anymore available\n"
	msgstr "parts de la clau secreta no estan disponbles\n"

	msgid "Your selection? "
	msgstr "La vostra selecció? "

	msgid "[not set]"
	msgstr "[no establert]"

	msgid "Mr."
	msgstr ""

	msgid "Ms."
	msgstr ""

	# Gènere? Nombre? Passat, futur? ivb
	# Probablement és una clau, femení. jm
	# Werner FIXME: please add translator comment saying what is
	# uncompressed so we know the gender. jm
	msgid "not forced"
	msgstr "no forçat"

	msgid "forced"
	msgstr "forçat"

	msgid "Error: Only plain ASCII is currently allowed.\n"
	msgstr ""

	msgid "Error: The \"<\" character may not be used.\n"
	msgstr ""

	msgid "Error: Double spaces are not allowed.\n"
	msgstr ""

	msgid "Cardholder's surname: "
	msgstr ""

	msgid "Cardholder's given name: "
	msgstr ""

	#, c-format
	msgid "Error: Combined name too long (limit is %d characters).\n"
	msgstr ""

	#, fuzzy
	msgid "URL to retrieve public key: "
	msgstr "no hi ha cap clau pública corresponent: %s\n"

	#, fuzzy, c-format
	#\| msgid "error reading `%s': %s\n"
	msgid "error reading '%s': %s\n"
	msgstr "error en la lectura de «%s»: %s\n"

	#, fuzzy, c-format
	msgid "error writing '%s': %s\n"
	msgstr "error mentre s'escrivia l'anell «%s»: %s\n"

	msgid "Login data (account name): "
	msgstr ""

	msgid "Private DO data: "
	msgstr ""

	#, fuzzy
	msgid "Language preferences: "
	msgstr "preferències actualitzades"

	#, fuzzy
	msgid "Error: invalid length of preference string.\n"
	msgstr "hi ha un caràcter invàlid en la cadena de preferència\n"

	#, fuzzy
	msgid "Error: invalid characters in preference string.\n"
	msgstr "hi ha un caràcter invàlid en la cadena de preferència\n"

	msgid "Salutation (M = Mr., F = Ms., or space): "
	msgstr ""

	#, fuzzy
	msgid "Error: invalid response.\n"
	msgstr "error: l'empremta digital és invàlida\n"

	#, fuzzy
	msgid "CA fingerprint: "
	msgstr "Empremta digital:"

	#, fuzzy
	msgid "Error: invalid formatted fingerprint.\n"
	msgstr "error: l'empremta digital és invàlida\n"

	#, fuzzy, c-format
	msgid "key operation not possible: %s\n"
	msgstr "La generació de claus ha fallat: %s\n"

	#, fuzzy
	msgid "not an OpenPGP card"
	msgstr "no s'han trobat dades OpenPGP vàlides.\n"

	#, fuzzy, c-format
	msgid "error getting current key info: %s\n"
	msgstr "s'ha produït un error mentre s'escrivia l'anell secret «%s»: %s\n"

	msgid "Replace existing key? (y/N) "
	msgstr ""

	msgid ""
	"Note: There is no guarantee that the card supports the requested size.\n"
	" If the key generation does not succeed, please check the\n"
	" documentation of your card to see what sizes are allowed.\n"
	msgstr ""

	#, fuzzy, c-format
	msgid "What keysize do you want? (%u) "
	msgstr "Quina grandària voleu? (1024) "

	#, c-format
	msgid "rounded up to %u bits\n"
	msgstr "arrodonida fins a %u bits\n"

	#, c-format
	msgid "%s keysizes must be in the range %u-%u\n"
	msgstr ""

	msgid "Changing card key attribute for: "
	msgstr ""

	#, fuzzy
	msgid "Signature key\n"
	msgstr "Aquesta signatura va caducar el %s\n"

	#, fuzzy
	msgid "Encryption key\n"
	msgstr " (%d) RSA (només xifrar)\n"

	msgid "Authentication key\n"
	msgstr ""

	msgid "Please select what kind of key you want:\n"
	msgstr "Seleccioneu quin tipus de clau voleu:\n"

	#, fuzzy, c-format
	msgid " (%d) RSA\n"
	msgstr " (%d) RSA (només signar)\n"

	#, fuzzy, c-format
	msgid " (%d) ECC\n"
	msgstr " (%d) DSA i ElGamal (predeterminat)\n"

	msgid "Invalid selection.\n"
	msgstr "La selecció és invàlida.\n"

	#, c-format
	msgid "The card will now be re-configured to generate a key of %u bits\n"
	msgstr ""

	#, c-format
	msgid "The card will now be re-configured to generate a key of type: %s\n"
	msgstr ""

	#, fuzzy, c-format
	msgid "error changing key attribute for key %d: %s\n"
	msgstr "error mentre s'enviava a «%s»: %s\n"

	#, fuzzy, c-format
	msgid "error getting card info: %s\n"
	msgstr "s'ha produït un error mentre s'escrivia l'anell secret «%s»: %s\n"

	#, fuzzy, c-format
	#\| msgid "This command is not allowed while in %s mode.\n"
	msgid "This command is not supported by this card\n"
	msgstr "Aquesta ordre no està permesa mentre s'està en mode %s.\n"

	msgid "Make off-card backup of encryption key? (Y/n) "
	msgstr ""

	#, fuzzy, c-format
	msgid "Note: keys are already stored on the card!\n"
	msgstr "es descarta: la clau secreta ja és present\n"

	msgid "Replace existing keys? (y/N) "
	msgstr ""

	#, c-format
	msgid ""
	"Please note that the factory settings of the PINs are\n"
	" PIN = '%s' Admin PIN = '%s'\n"
	"You should change them using the command --change-pin\n"
	msgstr ""

	#, fuzzy
	msgid "Please select the type of key to generate:\n"
	msgstr "Seleccioneu quin tipus de clau voleu:\n"

	msgid " (1) Signature key\n"
	msgstr ""

	#, fuzzy
	msgid " (2) Encryption key\n"
	msgstr " (%d) RSA (només xifrar)\n"

	msgid " (3) Authentication key\n"
	msgstr ""

	#, fuzzy
	msgid "Please select where to store the key:\n"
	msgstr "Seleccioneu la raó de la revocació:\n"

	#, fuzzy, c-format
	msgid "KEYTOCARD failed: %s\n"
	msgstr "ha fallat l'actualització: %s\n"

	#, fuzzy, c-format
	msgid "Note: This command destroys all keys stored on the card!\n"
	msgstr "es descarta: la clau secreta ja és present\n"

	#, fuzzy
	msgid "Continue? (y/N) "
	msgstr "Signar realment? "

	msgid "Really do a factory reset? (enter \"yes\") "
	msgstr ""

	#, fuzzy, c-format
	msgid "error for setup KDF: %s\n"
	msgstr "error en la lectura de «%s»: %s\n"

	msgid "quit this menu"
	msgstr "ix del menú"

	#, fuzzy
	msgid "show admin commands"
	msgstr "les ordres entren en conflicte\n"

	# «pantalla» o «ajuda»? ivb
	# «ajuda», evidentment. jm
	msgid "show this help"
	msgstr "mostra aquesta ajuda"

	#, fuzzy
	msgid "list all available data"
	msgstr "La clau és disponible en: "

	msgid "change card holder's name"
	msgstr ""

	msgid "change URL to retrieve key"
	msgstr ""

	msgid "fetch the key specified in the card URL"
	msgstr ""

	#, fuzzy
	msgid "change the login name"
	msgstr "canvia la data de caducitat"

	#, fuzzy
	msgid "change the language preferences"
	msgstr "canvia la confiança"

	msgid "change card holder's salutation"
	msgstr ""

	#, fuzzy
	msgid "change a CA fingerprint"
	msgstr "mostra empremta"

	msgid "toggle the signature force PIN flag"
	msgstr ""

	#, fuzzy
	msgid "generate new keys"
	msgstr "genera un nou parell de claus"

	msgid "menu to change or unblock the PIN"
	msgstr ""

	msgid "verify the PIN and list all data"
	msgstr ""

	msgid "unblock the PIN using a Reset Code"
	msgstr ""

	msgid "destroy all keys and data"
	msgstr ""

	#, fuzzy
	#\| msgid "\|NAME\|use NAME as default recipient"
	msgid "setup KDF for PIN authentication"
	msgstr "\|NOM\|usa NOM com a destinatari predeterminat"

	#, fuzzy
	#\| msgid "change the ownertrust"
	msgid "change the key attribute"
	msgstr "canvia la confiança"

	msgid "gpg/card> "
	msgstr ""

	#, fuzzy
	msgid "Admin-only command\n"
	msgstr "les ordres entren en conflicte\n"

	msgid "Admin commands are allowed\n"
	msgstr ""

	msgid "Admin commands are not allowed\n"
	msgstr ""

	msgid "Invalid command (try \"help\")\n"
	msgstr "L'ordre no és vàlida (proveu «help»)\n"

	#, c-format
	msgid "--output doesn't work for this command\n"
	msgstr "--output no funciona per a aquesta ordre\n"

	#, fuzzy, c-format
	#\| msgid "can't open `%s'\n"
	msgid "can't open '%s'\n"
	msgstr "no s'ha pogut obrir «%s»\n"

	#, fuzzy, c-format
	msgid "key \"%s\" not found: %s\n"
	msgstr "no s'ha trobat la clau «%s»: %s\n"

	#, c-format
	msgid "error reading keyblock: %s\n"
	msgstr "s'ha produït un error en llegir el bloc de claus: %s\n"

	#, fuzzy, c-format
	msgid "key \"%s\" not found\n"
	msgstr "no s'ha trobat la clau «%s»: %s\n"

	#, c-format
	msgid "(unless you specify the key by fingerprint)\n"
	msgstr "(a no ser que especifiqueu la clau per la empremta digital)\n"

	# Ahà! Abans «batch» està tal qual. Cal unificar. ivb
	# Fet. jm
	#, fuzzy, c-format
	msgid "can't do this in batch mode without \"--yes\"\n"
	msgstr "no es pot fer això en el mode desatès sense «--yes»\n"

	msgid "Note: The public primary key and all its subkeys will be deleted.\n"
	msgstr ""

	msgid "Note: Only the shown public subkey will be deleted.\n"
	msgstr ""

	msgid "Note: Only the secret part of the shown primary key will be deleted.\n"
	msgstr ""

	msgid "Note: Only the secret part of the shown subkey will be deleted.\n"
	msgstr ""

	#, fuzzy
	msgid "Delete this key from the keyring? (y/N) "
	msgstr "Voleu esborrar aquesta clau de l'anell? "

	#, fuzzy
	msgid "This is a secret key! - really delete? (y/N) "
	msgstr "És una clau secreta! Voleu esborrar-la? "

	#, fuzzy, c-format
	msgid "deleting secret %s failed: %s\n"
	msgstr "no s'ha pogut eliminar el bloc de claus: %s\n"

	msgid "key"
	msgstr "clau"

	#, fuzzy
	#\| msgid "Pubkey: "
	msgid "subkey"
	msgstr "Clau pública: "

	#, c-format
	msgid "update failed: %s\n"
	msgstr "ha fallat l'actualització: %s\n"

	#, c-format
	msgid "deleting keyblock failed: %s\n"
	msgstr "no s'ha pogut eliminar el bloc de claus: %s\n"

	#, c-format
	msgid "ownertrust information cleared\n"
	msgstr "s'ha netejat la informació de la confiança\n"

	#, c-format
	msgid "there is a secret key for public key \"%s\"!\n"
	msgstr "hi ha una clau secreta per a la clau pública «%s»!\n"

	#, c-format
	msgid "use option \"--delete-secret-keys\" to delete it first.\n"
	msgstr "utilitzeu l'opció «--delete-secret-keys» per a eliminar-la primer.\n"

	#, fuzzy, c-format
	msgid ""
	"WARNING: forcing symmetric cipher %s (%d) violates recipient preferences\n"
	msgstr ""
	"forçar el xifrat asimètric %s (%d) viola les preferències del destinatari\n"

	#, c-format
	msgid "error creating passphrase: %s\n"
	msgstr "error en la creació de la contrasenya: %s\n"

	#, fuzzy, c-format
	#\| msgid "can't use a symmetric ESK packet due to the S2K mode\n"
	msgid "can't use a SKESK packet due to the S2K mode\n"
	msgstr "no es pot usar un paquet asimètric ESK al estar en mode S2K\n"

	#, fuzzy, c-format
	msgid "using cipher %s.%s\n"
	msgstr "Ha fallat el procés de signatura: %s\n"

	#, fuzzy, c-format
	#\| msgid "`%s' already compressed\n"
	msgid "'%s' already compressed\n"
	msgstr "«%s» ja està comprimida\n"

	#, fuzzy, c-format
	#\| msgid "WARNING: `%s' is an empty file\n"
	msgid "WARNING: '%s' is an empty file\n"
	msgstr "AVÍS: «%s» és un fitxer buit\n"

	#, fuzzy, c-format
	msgid "cipher algorithm '%s' may not be used in %s mode\n"
	msgstr "no podeu usar l'algorisme de xifratge «%s» mentre esteu en mode %s\n"

	#, fuzzy, c-format
	msgid "digest algorithm '%s' may not be used in %s mode\n"
	msgstr "no podeu usar l'algorisme de resum %s mentre esteu en mode %s\n"

	#, fuzzy, c-format
	msgid "WARNING: key %s is not suitable for encryption in %s mode\n"
	msgstr "AVÍS: %s és una opció desaconsellada.\n"

	#, fuzzy, c-format
	#\| msgid "reading from `%s'\n"
	msgid "reading from '%s'\n"
	msgstr "s'està llegint des de «%s»\n"

	#, fuzzy, c-format
	msgid ""
	"WARNING: forcing compression algorithm %s (%d) violates recipient "
	"preferences\n"
	msgstr ""
	"forçar l'algoritme de compressió %s (%d) viola les preferències del "
	"destinatari\n"

	#, fuzzy, c-format
	#\| msgid "%s/%s encrypted for: \"%s\"\n"
	msgid "%s/%s.%s encrypted for: \"%s\"\n"
	msgstr "%s/%s xifrat per a: «%s»\n"

	#, fuzzy, c-format
	#\| msgid "you may not use %s while in %s mode\n"
	msgid "option '%s' may not be used in %s mode\n"
	msgstr "no podeu usar %s mentre esteu en mode %s\n"

	#, c-format
	msgid "%s encrypted data\n"
	msgstr "dades xifrades amb %s\n"

	#, c-format
	msgid "encrypted with unknown algorithm %d\n"
	msgstr "xifrat amb l'algoritme %d (desconegut)\n"

	# És no-wrap? ivb
	# Com? jm
	#, c-format
	msgid ""
	"WARNING: message was encrypted with a weak key in the symmetric cipher.\n"
	msgstr ""
	"ATENCIÓ: el missatge s'ha xifrat amb una clau feble durant el xifratge\n"
	"simètric.\n"

	#, c-format
	msgid "problem handling encrypted packet\n"
	msgstr "problema en tractar amb un paquet xifrat\n"

	# Execució de programes remots, o execució remota de programes? jm
	#, c-format
	msgid "no remote program execution supported\n"
	msgstr "no hi ha suport per a l'execució remota de programes\n"

	#, c-format
	msgid ""
	"external program calls are disabled due to unsafe options file permissions\n"
	msgstr ""
	"les crides a programes externs estan inhabilitades per tindre el fitxer "
	"d'opcions permissos insegurs\n"

	#, fuzzy, c-format
	msgid "this platform requires temporary files when calling external programs\n"
	msgstr ""
	"aquesta plataforma necessita fitxers temporals quan es crida a programes "
	"externs\n"

	#, fuzzy, c-format
	msgid "unable to execute program '%s': %s\n"
	msgstr "no s'ha pogut executar %s «%s»: %s\n"

	#, fuzzy, c-format
	msgid "unable to execute shell '%s': %s\n"
	msgstr "no s'ha pogut executar %s «%s»: %s\n"

	#, c-format
	msgid "system error while calling external program: %s\n"
	msgstr "s'ha produït un error del sistema en cridar el programa extern: %s\n"

	#, c-format
	msgid "unnatural exit of external program\n"
	msgstr "s'ha produït una eixida no natural del programa extern\n"

	#, c-format
	msgid "unable to execute external program\n"
	msgstr "no s'ha pogut executar el programa extern\n"

	#, c-format
	msgid "unable to read external program response: %s\n"
	msgstr "no s'ha pogut llegir la resposta del programa extern: %s\n"

	#, fuzzy, c-format
	#\| msgid "WARNING: unable to remove tempfile (%s) `%s': %s\n"
	msgid "WARNING: unable to remove tempfile (%s) '%s': %s\n"
	msgstr "AVÍS: no s'ha pogut eliminar el fitxer temporal (%s) «%s»: %s\n"

	#, fuzzy, c-format
	#\| msgid "WARNING: unable to remove temp directory `%s': %s\n"
	msgid "WARNING: unable to remove temp directory '%s': %s\n"
	msgstr "AVÍS: no s'ha pogut eliminar el directori temporal «%s»: %s\n"

	#, fuzzy
	msgid "export signatures that are marked as local-only"
	msgstr ""
	"\n"
	"La signatura es marcarà com a irrevocable.\n"

	msgid "export attribute user IDs (generally photo IDs)"
	msgstr ""

	#, fuzzy
	msgid "export revocation keys marked as \"sensitive\""
	msgstr "no s'han ttrobat claus de revocació per a «%s»\n"

	#, fuzzy
	msgid "remove unusable parts from key during export"
	msgstr "la clau secreta és inusable"

	msgid "remove as much as possible from key during export"
	msgstr ""

	#, fuzzy
	#\| msgid "generate a revocation certificate"
	msgid "export only revocation certificates"
	msgstr "genera un certificat de revocació"

	msgid "use the GnuPG key backup format"
	msgstr ""

	#, fuzzy
	#\| msgid "%s: skipped: %s\n"
	msgid " - skipped"
	msgstr "%s: es descarta: %s\n"

	#, fuzzy, c-format
	#\| msgid "writing to `%s'\n"
	msgid "writing to '%s'\n"
	msgstr "s'està escrivint en «%s»\n"

	#, fuzzy, c-format
	msgid "key %s: key material on-card - skipped\n"
	msgstr ""
	"clau %08lX: la signatura de la subclau és en el lloc equivocat - es "
	"descarta\n"

	#, fuzzy, c-format
	msgid "exporting secret keys not allowed\n"
	msgstr "s'està escrivint la clau secreta a «%s»\n"

	#, fuzzy, c-format
	msgid "key %s: PGP 2.x style key - skipped\n"
	msgstr "clau %08lX: clau d'estil PGP 2.x - es descarta\n"

	#, c-format
	msgid "WARNING: nothing exported\n"
	msgstr "AVÍS: no s'ha exportat res\n"

	#, fuzzy, c-format
	#\| msgid "error creating `%s': %s\n"
	msgid "error creating '%s': %s\n"
	msgstr "error en crear «%s»: %s\n"

	#, fuzzy
	msgid "[User ID not found]"
	msgstr "[No s'ha trobat l'id d'usuari]"

	#, fuzzy, c-format
	msgid "automatically retrieved '%s' via %s\n"
	msgstr "error en crear «%s»: %s\n"

	#, fuzzy, c-format
	msgid "error retrieving '%s' via %s: %s\n"
	msgstr "error en crear «%s»: %s\n"

	#, fuzzy
	msgid "No fingerprint"
	msgstr "Empremta digital:"

	#, c-format
	msgid "checking for a fresh copy of an expired key via %s\n"
	msgstr ""

	#, fuzzy, c-format
	msgid "secret key \"%s\" not found: %s\n"
	msgstr "no s'ha trobat la clau secreta «%s»: %s\n"

	#, fuzzy, c-format
	msgid "(check argument of option '%s')\n"
	msgstr "opcions d'importació no vàlides\n"

	#, fuzzy, c-format
	#\| msgid "\|NAME\|use NAME as default secret key"
	msgid "Warning: not using '%s' as default key: %s\n"
	msgstr "\|NOM\|usa NOM com a clau secreta predeterminada"

	#, fuzzy, c-format
	#\| msgid "\|NAME\|use NAME as default secret key"
	msgid "using \"%s\" as default secret key for signing\n"
	msgstr "\|NOM\|usa NOM com a clau secreta predeterminada"

	#, c-format
	msgid "all values passed to '%s' ignored\n"
	msgstr ""

	#, fuzzy, c-format
	msgid "Invalid key %s made valid by --allow-non-selfsigned-uid\n"
	msgstr ""
	"La clau invàlida %08lX s'ha fet vàlida amb --allow-non-selfsigned-uid\n"

	#, fuzzy, c-format
	msgid "using subkey %s instead of primary key %s\n"
	msgstr "s'usarà la clau secundària %08lX en lloc de la primària %08lX\n"

	#, fuzzy, c-format
	msgid "valid values for option '%s':\n"
	msgstr "opcions d'importació no vàlides\n"

	#, fuzzy
	msgid "make a signature"
	msgstr "\|[fitxer]\|crea una signatura"

	#, fuzzy
	msgid "make a clear text signature"
	msgstr "\|[fitxer]\|crea una signatura en text clar"

	msgid "make a detached signature"
	msgstr "crea una signatura separada"

	msgid "encrypt data"
	msgstr "xifra dades"

	msgid "encryption only with symmetric cipher"
	msgstr "xifra només amb xifratge simètric"

	msgid "decrypt data (default)"
	msgstr "desxifra dades (predeterminat)"

	msgid "verify a signature"
	msgstr "verifica una signatura"

	msgid "list keys"
	msgstr "llista claus"

	msgid "list keys and signatures"
	msgstr "llista claus i signatures"

	# «de les claus» o «de la clau»? ivb
	#, fuzzy
	msgid "list and check key signatures"
	msgstr "comprova les signatures de la claus"

	# «dactilars» o «digitals»? ivb
	msgid "list keys and fingerprints"
	msgstr "llista claus i empremtes digitals"

	msgid "list secret keys"
	msgstr "llista claus secretes"

	msgid "generate a new key pair"
	msgstr "genera un nou parell de claus"

	#, fuzzy
	#\| msgid "generate a new key pair"
	msgid "quickly generate a new key pair"
	msgstr "genera un nou parell de claus"

	#, fuzzy
	#\| msgid "generate a new key pair"
	msgid "quickly add a new user-id"
	msgstr "genera un nou parell de claus"

	#, fuzzy
	#\| msgid "generate a new key pair"
	msgid "quickly revoke a user-id"
	msgstr "genera un nou parell de claus"

	#, fuzzy
	#\| msgid "generate a new key pair"
	msgid "quickly set a new expiration date"
	msgstr "genera un nou parell de claus"

	msgid "full featured key pair generation"
	msgstr ""

	msgid "generate a revocation certificate"
	msgstr "genera un certificat de revocació"

	msgid "remove keys from the public keyring"
	msgstr "elimina claus de l'anell públic"

	msgid "remove keys from the secret keyring"
	msgstr "elimina claus de l'anell secret"

	#, fuzzy
	#\| msgid "sign a key"
	msgid "quickly sign a key"
	msgstr "signa una clau"

	#, fuzzy
	#\| msgid "sign a key locally"
	msgid "quickly sign a key locally"
	msgstr "signa una clau localment"

	#, fuzzy
	#\| msgid "generate a new key pair"
	msgid "quickly revoke a key signature"
	msgstr "genera un nou parell de claus"

	msgid "sign a key"
	msgstr "signa una clau"

	msgid "sign a key locally"
	msgstr "signa una clau localment"

	msgid "sign or edit a key"
	msgstr "signa o edita una clau"

	#, fuzzy
	msgid "change a passphrase"
	msgstr "canvia la contrasenya"

	msgid "export keys"
	msgstr "exporta claus"

	msgid "export keys to a keyserver"
	msgstr "exporta claus a un servidor de claus"

	msgid "import keys from a keyserver"
	msgstr "importa claus d'un servidor de claus"

	msgid "search for keys on a keyserver"
	msgstr "cerca claus en un servidor de claus"

	msgid "update all keys from a keyserver"
	msgstr "actualitza totes les claus des d'un servidor de claus"

	msgid "import/merge keys"
	msgstr "importa/fon claus"

	msgid "print the card status"
	msgstr ""

	msgid "change data on a card"
	msgstr ""

	msgid "change a card's PIN"
	msgstr ""

	msgid "update the trust database"
	msgstr "actualitza la base de dades de confiança"

	#, fuzzy
	msgid "print message digests"
	msgstr "\|algo [fitxers]\|imprimeix resums de missatges"

	msgid "run in server mode"
	msgstr ""

	msgid "\|VALUE\|set the TOFU policy for a key"
	msgstr ""

	msgid "\|NAME\|use NAME as default secret key"
	msgstr "\|NOM\|usa NOM com a clau secreta predeterminada"

	#, fuzzy
	msgid "\|NAME\|encrypt to user ID NAME as well"
	msgstr "\|NOM\|xifra per a NOM"

	msgid "\|SPEC\|set up email aliases"
	msgstr ""

	msgid "use strict OpenPGP behavior"
	msgstr ""

	msgid "do not make any changes"
	msgstr "no fa cap canvi"

	msgid "prompt before overwriting"
	msgstr "pregunta abans de sobreescriure"

	msgid "Options controlling the input"
	msgstr ""

	msgid "Options controlling the output"
	msgstr ""

	msgid "create ascii armored output"
	msgstr "crea eixida amb armadura ascii"

	#, fuzzy
	msgid "\|FILE\|write output to FILE"
	msgstr "\|FITXER\|carrega el mòdul d'extensió especificat"

	msgid "use canonical text mode"
	msgstr "usa el mode de text canònic"

	#, fuzzy
	msgid "\|N\|set compress level to N (0 disables)"
	msgstr "\|N\|nivell de compressió N (0 no comprimeix)"

	msgid "Options controlling key import and export"
	msgstr ""

	msgid "\|MECHANISMS\|use MECHANISMS to locate keys by mail address"
	msgstr ""

	#, fuzzy
	#\| msgid "import keys from a keyserver"
	msgid "import missing key from a signature"
	msgstr "importa claus d'un servidor de claus"

	# «de les claus» o «de la clau»? ivb
	#, fuzzy
	msgid "include the public key in signatures"
	msgstr "comprova les signatures de la claus"

	msgid "disable all access to the dirmngr"
	msgstr ""

	msgid "Options controlling key listings"
	msgstr ""

	#, fuzzy
	#\| msgid "list secret keys"
	msgid "Options to specify keys"
	msgstr "llista claus secretes"

	#, fuzzy
	msgid "\|USER-ID\|encrypt for USER-ID"
	msgstr "\|NOM\|xifra per a NOM"

	#, fuzzy
	msgid "\|USER-ID\|use USER-ID to sign or decrypt"
	msgstr "usa aquest id per a signar o desxifrar"

	msgid "Options for unattended use"
	msgstr ""

	msgid "Other options"
	msgstr ""

	msgid ""
	"@\n"
	"(See the man page for a complete listing of all commands and options)\n"
	msgstr ""
	"@\n"
	"(En la pàgina del man hi ha una llista completa d'ordres i d'opcions)\n"

	# Crec q (A)lice (orig.), (B)ob (dest.), etc. són noms usats pel Zimmerman
	# en el manual original de PGP. A, B, C... ivb
	# En efecte. Idem per a Mallory més endavant. Els deixe com a l'original. jm
	#, fuzzy
	#\| msgid ""
	#\| "@\n"
	#\| "Examples:\n"
	#\| "\n"
	#\| " -se -r Bob [file] sign and encrypt for user Bob\n"
	#\| " --clear-sign [file] make a clear text signature\n"
	#\| " --detach-sign [file] make a detached signature\n"
	#\| " --list-keys [names] show keys\n"
	#\| " --fingerprint [names] show fingerprints\n"
	msgid ""
	"@\n"
	"Examples:\n"
	"\n"
	" -se -r Bob [file] sign and encrypt for user Bob\n"
	" --clear-sign [file] make a clear text signature\n"
	" --detach-sign [file] make a detached signature\n"
	" --list-keys [names] show keys\n"
	" --fingerprint [names] show fingerprints\n"
	msgstr ""
	"@\n"
	"Exemples:\n"
	"\n"
	" -se -r Bob [fitxer] signa i xifra per a l'usuari Bob\n"
	" --clear-sign [fitxer] crea una signatura en text clar\n"
	" --detach-sign [fitxer] crea una signatura separada\n"
	" --list-keys [noms] mostra claus\n"
	" --fingerprint [noms] mostra empremtes digitals\n"

	#, fuzzy
	#\| msgid "Usage: gpg [options] [files] (-h for help)"
	msgid "Usage: @GPG@ [options] [files] (-h for help)"
	msgstr "Forma d'ús: gpg [opcions] [fitxers] (-h per a veure l'ajuda)"

	#, fuzzy
	#\| msgid ""
	#\| "Syntax: gpg [options] [files]\n"
	#\| "sign, check, encrypt or decrypt\n"
	#\| "default operation depends on the input data\n"
	msgid ""
	"Syntax: @GPG@ [options] [files]\n"
	"Sign, check, encrypt or decrypt\n"
	"Default operation depends on the input data\n"
	msgstr ""
	"Sintaxi: gpg [opcions] [fitxers]\n"
	"signa, comprova, xifra o desxifra\n"
	"l'operació predeterminada depén de les dades introduïdes\n"

	# Suportats? ivb
	# A Softcatalà diuen molt «implementat». jm
	# Precissament acabem de parlar d'«implementat a la llista del GNOME
	# i s'ha dit que és erroni, igual que «suportat» :) Les alternatives
	# encara no m'agraden massa... jm
	msgid ""
	"\n"
	"Supported algorithms:\n"
	msgstr ""
	"\n"
	"Algoritmes suportats:\n"

	msgid "Pubkey: "
	msgstr "Clau pública: "

	msgid "Cipher: "
	msgstr "Xifratge: "

	msgid "Hash: "
	msgstr "Dispersió: "

	msgid "Compression: "
	msgstr "Compressió: "

	#, fuzzy, c-format
	msgid "usage: %s [options] %s\n"
	msgstr "forma d'ús: gpg [opcions] "

	#, c-format
	msgid "conflicting commands\n"
	msgstr "les ordres entren en conflicte\n"

	#, fuzzy, c-format
	#\| msgid "no = sign found in group definition `%s'\n"
	msgid "no = sign found in group definition '%s'\n"
	msgstr "no s'ha trobat cap signe = a la definició de grup «%s»\n"

	# Indi. ivb
	#, fuzzy, c-format
	msgid "WARNING: unsafe ownership on homedir '%s'\n"
	msgstr "AVÍS: el propietari és insegur en %s «%s»\n"

	# Indi. ivb
	#, fuzzy, c-format
	msgid "WARNING: unsafe ownership on configuration file '%s'\n"
	msgstr "AVÍS: el propietari és insegur en %s «%s»\n"

	# Indi. ivb
	#, fuzzy, c-format
	msgid "WARNING: unsafe ownership on extension '%s'\n"
	msgstr "AVÍS: el propietari és insegur en %s «%s»\n"

	#, fuzzy, c-format
	msgid "WARNING: unsafe permissions on homedir '%s'\n"
	msgstr "AVÍS: els permissos són insegurs en %s «%s»\n"

	#, fuzzy, c-format
	msgid "WARNING: unsafe permissions on configuration file '%s'\n"
	msgstr "AVÍS: els permissos són insegurs en %s «%s»\n"

	#, fuzzy, c-format
	msgid "WARNING: unsafe permissions on extension '%s'\n"
	msgstr "AVÍS: els permissos són insegurs en %s «%s»\n"

	#, fuzzy, c-format
	msgid "WARNING: unsafe enclosing directory ownership on homedir '%s'\n"
	msgstr "AVÍS: el propietari del directori envoltant és insegur en %s «%s»\n"

	#, fuzzy, c-format
	msgid ""
	"WARNING: unsafe enclosing directory ownership on configuration file '%s'\n"
	msgstr "AVÍS: el propietari del directori envoltant és insegur en %s «%s»\n"

	#, fuzzy, c-format
	msgid "WARNING: unsafe enclosing directory ownership on extension '%s'\n"
	msgstr "AVÍS: el propietari del directori envoltant és insegur en %s «%s»\n"

	#, fuzzy, c-format
	msgid "WARNING: unsafe enclosing directory permissions on homedir '%s'\n"
	msgstr "AVÍS: els permissos del directori envoltant són insegurs en %s «%s»\n"

	#, fuzzy, c-format
	msgid ""
	"WARNING: unsafe enclosing directory permissions on configuration file '%s'\n"
	msgstr "AVÍS: els permissos del directori envoltant són insegurs en %s «%s»\n"

	#, fuzzy, c-format
	msgid "WARNING: unsafe enclosing directory permissions on extension '%s'\n"
	msgstr "AVÍS: els permissos del directori envoltant són insegurs en %s «%s»\n"

	#, fuzzy, c-format
	msgid "unknown configuration item '%s'\n"
	msgstr "s'ha creat el nou fitxer d'opcions «%s»\n"

	msgid "display photo IDs during key listings"
	msgstr ""

	#, fuzzy
	msgid "show key usage information during key listings"
	msgstr "No hi ha cap signatura corresponent en l'anell secret\n"

	msgid "show policy URLs during signature listings"
	msgstr ""

	#, fuzzy
	msgid "show all notations during signature listings"
	msgstr "No hi ha cap signatura corresponent en l'anell secret\n"

	msgid "show IETF standard notations during signature listings"
	msgstr ""

	msgid "show user-supplied notations during signature listings"
	msgstr ""

	#, fuzzy
	msgid "show preferred keyserver URLs during signature listings"
	msgstr "la URL de política de signatura donada no és vàlida\n"

	msgid "show user ID validity during key listings"
	msgstr ""

	msgid "show revoked and expired user IDs in key listings"
	msgstr ""

	msgid "show revoked and expired subkeys in key listings"
	msgstr ""

	#, fuzzy
	msgid "show the keyring name in key listings"
	msgstr "mostra en quin anell de claus està una clau llistada"

	#, fuzzy
	msgid "show expiration dates during signature listings"
	msgstr "No hi ha cap signatura corresponent en l'anell secret\n"

	#, fuzzy
	#\| msgid "set preference list"
	msgid "show preferences"
	msgstr "estableix la llista de preferències"

	#, fuzzy, c-format
	msgid "unknown TOFU policy '%s'\n"
	msgstr "el destinatari predeterminat és desconegut «%s»\n"

	#, c-format
	msgid "(use \"help\" to list choices)\n"
	msgstr ""

	#, c-format
	msgid "This command is not allowed while in %s mode.\n"
	msgstr "Aquesta ordre no està permesa mentre s'està en mode %s.\n"

	#, fuzzy, c-format
	#\| msgid "NOTE: %s is not for normal use!\n"
	msgid "Note: %s is not for normal use!\n"
	msgstr "NOTA: %s no és per a ús normal!\n"

	#, fuzzy, c-format
	msgid "'%s' is not a valid signature expiration\n"
	msgstr "%s no és un joc de caràcters vàlid\n"

	#, fuzzy, c-format
	msgid "\"%s\" is not a proper mail address\n"
	msgstr "No és una adreça vàlida\n"

	#, fuzzy, c-format
	msgid "invalid pinentry mode '%s'\n"
	msgstr "l'algoritme de dispersió és invàlid «%s»\n"

	#, fuzzy, c-format
	msgid "invalid request origin '%s'\n"
	msgstr "opcions d'importació no vàlides\n"

	#, fuzzy, c-format
	msgid "'%s' is not a valid character set\n"
	msgstr "%s no és un joc de caràcters vàlid\n"

	#, fuzzy, c-format
	msgid "could not parse keyserver URL\n"
	msgstr "no s'ha pogut analitzar sintàcticament la URI del servidor de claus\n"

	#, fuzzy, c-format
	msgid "%s:%d: invalid keyserver options\n"
	msgstr "%s:%d opcions d'exportació no vàlides\n"

	#, fuzzy, c-format
	msgid "invalid keyserver options\n"
	msgstr "opcions d'exportació no vàlides\n"

	#, c-format
	msgid "%s:%d: invalid import options\n"
	msgstr "%s:%d: opcions d'importanció no vàlides\n"

	#, c-format
	msgid "invalid import options\n"
	msgstr "opcions d'importació no vàlides\n"

	#, fuzzy, c-format
	msgid "invalid filter option: %s\n"
	msgstr "opcions d'importació no vàlides\n"

	#, c-format
	msgid "%s:%d: invalid export options\n"
	msgstr "%s:%d opcions d'exportació no vàlides\n"

	#, c-format
	msgid "invalid export options\n"
	msgstr "opcions d'exportació no vàlides\n"

	#, fuzzy, c-format
	msgid "%s:%d: invalid list options\n"
	msgstr "%s:%d: opcions d'importanció no vàlides\n"

	#, fuzzy, c-format
	msgid "invalid list options\n"
	msgstr "opcions d'importació no vàlides\n"

	msgid "display photo IDs during signature verification"
	msgstr ""

	msgid "show policy URLs during signature verification"
	msgstr ""

	#, fuzzy
	msgid "show all notations during signature verification"
	msgstr "%s no és un joc de caràcters vàlid\n"

	msgid "show IETF standard notations during signature verification"
	msgstr ""

	msgid "show user-supplied notations during signature verification"
	msgstr ""

	#, fuzzy
	msgid "show preferred keyserver URLs during signature verification"
	msgstr "la URL de política de signatura donada no és vàlida\n"

	#, fuzzy
	msgid "show user ID validity during signature verification"
	msgstr "%s no és un joc de caràcters vàlid\n"

	msgid "show revoked and expired user IDs in signature verification"
	msgstr ""

	#, fuzzy
	msgid "show only the primary user ID in signature verification"
	msgstr "%s no és un joc de caràcters vàlid\n"

	msgid "validate signatures with PKA data"
	msgstr ""

	msgid "elevate the trust of signatures with valid PKA data"
	msgstr ""

	#, fuzzy, c-format
	msgid "%s:%d: invalid verify options\n"
	msgstr "%s:%d opcions d'exportació no vàlides\n"

	#, fuzzy, c-format
	msgid "invalid verify options\n"
	msgstr "opcions d'exportació no vàlides\n"

	#, c-format
	msgid "unable to set exec-path to %s\n"
	msgstr "no s'ha pogut fixar l'exec-path a %s\n"

	#, fuzzy, c-format
	msgid "%s:%d: invalid auto-key-locate list\n"
	msgstr "%s:%d opcions d'exportació no vàlides\n"

	#, c-format
	msgid "invalid auto-key-locate list\n"
	msgstr ""

	#, c-format
	msgid "WARNING: program may create a core file!\n"
	msgstr "AVÍS: el programa podria crear un fitxer core!\n"

	# FIXME: preferència? jm
	# Ho discutírem en la llista, segur. Deu ser als arxius. ivb
	#, c-format
	msgid "WARNING: %s overrides %s\n"
	msgstr "AVÍS: %s té preferència sobre %s\n"

	#, c-format
	msgid "%s not allowed with %s!\n"
	msgstr "%s no és permés amb %s!\n"

	#, c-format
	msgid "%s makes no sense with %s!\n"
	msgstr "%s no té sentit amb %s!\n"

	#, c-format
	msgid "WARNING: running with faked system time: "
	msgstr ""

	#, fuzzy, c-format
	msgid "will not run with insecure memory due to %s\n"
	msgstr "s'està escrivint la clau secreta a «%s»\n"

	#, c-format
	msgid "selected cipher algorithm is invalid\n"
	msgstr "l'algorisme de xifratge triat no és vàlid\n"

	#, fuzzy, c-format
	msgid "selected compression algorithm is invalid\n"
	msgstr "l'algorisme de xifratge triat no és vàlid\n"

	#, c-format
	msgid "selected certification digest algorithm is invalid\n"
	msgstr "l'algorisme de resum de certificació seleccionat no és vàlid\n"

	#, c-format
	msgid "completes-needed must be greater than 0\n"
	msgstr "completes-needed ha de ser major que 0\n"

	#, c-format
	msgid "marginals-needed must be greater than 1\n"
	msgstr "marginals-needed ha de ser major que 1\n"

	#, fuzzy, c-format
	msgid "max-cert-depth must be in the range from 1 to 255\n"
	msgstr "max-cert-depth ha d'estar en el rang 1 a 255\n"

	#, fuzzy, c-format
	msgid "invalid default-cert-level; must be 0, 1, 2, or 3\n"
	msgstr "default-check-level és invàlid; ha de ser 0, 1, 2 o 3\n"

	#, fuzzy, c-format
	msgid "invalid min-cert-level; must be 1, 2, or 3\n"
	msgstr "default-check-level és invàlid; ha de ser 0, 1, 2 o 3\n"

	#, fuzzy, c-format
	#\| msgid "NOTE: simple S2K mode (0) is strongly discouraged\n"
	msgid "Note: simple S2K mode (0) is strongly discouraged\n"
	msgstr "NOTA: el mode S2K simple (0) no és gens recomanable\n"

	#, c-format
	msgid "invalid S2K mode; must be 0, 1 or 3\n"
	msgstr "el mode S2K és invàlid; ha de ser 0, 1 o 3\n"

	#, c-format
	msgid "invalid default preferences\n"
	msgstr "les preferències per defecte són invàlides\n"

	#, c-format
	msgid "invalid personal cipher preferences\n"
	msgstr "les preferències personals de xifrat són invàlides\n"

	#, c-format
	msgid "invalid personal digest preferences\n"
	msgstr "les preferències personals de digest són invàlides\n"

	#, c-format
	msgid "invalid personal compress preferences\n"
	msgstr "les preferències personals de compressió són invàlides\n"

	#, c-format
	msgid "%s does not yet work with %s\n"
	msgstr "%s encara no funciona amb %s\n"

	#, fuzzy, c-format
	msgid "compression algorithm '%s' may not be used in %s mode\n"
	msgstr "no podeu usar l'algorisme de compressió %s mentre esteu en mode %s\n"

	#, c-format
	msgid "failed to initialize the TrustDB: %s\n"
	msgstr "no s'ha pogut inicialitzar la base de dades de confiança: %s\n"

	#, c-format
	msgid "WARNING: recipients (-r) given without using public key encryption\n"
	msgstr ""
	"AVÍS: s'han donat destinataris (-r) sense usar xifratge de clau pública\n"

	#, fuzzy, c-format
	msgid "symmetric encryption of '%s' failed: %s\n"
	msgstr "ha fallat el desxifratge: %s\n"

	#, c-format
	msgid "you cannot use --symmetric --encrypt with --s2k-mode 0\n"
	msgstr ""

	#, fuzzy, c-format
	msgid "you cannot use --symmetric --encrypt in %s mode\n"
	msgstr "no podeu usar %s mentre esteu en mode %s\n"

	#, c-format
	msgid "you cannot use --symmetric --sign --encrypt with --s2k-mode 0\n"
	msgstr ""

	#, fuzzy, c-format
	msgid "you cannot use --symmetric --sign --encrypt in %s mode\n"
	msgstr "no podeu usar %s mentre esteu en mode %s\n"

	#, c-format
	msgid "keyserver send failed: %s\n"
	msgstr "l'enviament al servidor de claus ha fallat: %s\n"

	#, c-format
	msgid "keyserver receive failed: %s\n"
	msgstr "la recepció des del servidor de claus ha fallat: %s\n"

	#, c-format
	msgid "key export failed: %s\n"
	msgstr "l'exportació de la clau ha fallat: %s\n"

	#, fuzzy, c-format
	#\| msgid "key export failed: %s\n"
	msgid "export as ssh key failed: %s\n"
	msgstr "l'exportació de la clau ha fallat: %s\n"

	#, c-format
	msgid "keyserver search failed: %s\n"
	msgstr "ha fallat la cerca al servidor de claus: %s\n"

	#, c-format
	msgid "keyserver refresh failed: %s\n"
	msgstr "ha fallat el refresc des del servidor de claus: %s\n"

	#, c-format
	msgid "dearmoring failed: %s\n"
	msgstr "no s'ha pogut llevar l'armadura: %s\n"

	#, c-format
	msgid "enarmoring failed: %s\n"
	msgstr "no s'ha pogut crear l'armadura: %s\n"

	#, fuzzy, c-format
	#\| msgid "invalid hash algorithm `%s'\n"
	msgid "invalid hash algorithm '%s'\n"
	msgstr "l'algoritme de dispersió és invàlid «%s»\n"

	#, fuzzy, c-format
	msgid "error parsing key specification '%s': %s\n"
	msgstr "error en la creació de la contrasenya: %s\n"

	#, c-format
	msgid "'%s' does not appear to be a valid key ID, fingerprint or keygrip\n"
	msgstr ""

	#, c-format
	msgid "WARNING: no command supplied. Trying to guess what you mean ...\n"
	msgstr ""

	#, c-format
	msgid "Go ahead and type your message ...\n"
	msgstr "Endavant, escriviu el missatge...\n"

	#, c-format
	msgid "the given certification policy URL is invalid\n"
	msgstr "la URL de política de certificació donada no és vàlida\n"

	#, c-format
	msgid "the given signature policy URL is invalid\n"
	msgstr "la URL de política de signatura donada no és vàlida\n"

	#, fuzzy, c-format
	msgid "the given preferred keyserver URL is invalid\n"
	msgstr "la URL de política de signatura donada no és vàlida\n"

	#, fuzzy
	msgid "\|FILE\|take the keys from the keyring FILE"
	msgstr "pren les claus d'aquest anell"

	msgid "make timestamp conflicts only a warning"
	msgstr "fes els conflictes de marques de temps només un avís"

	msgid "\|FD\|write status info to this FD"
	msgstr "\|FD\|escriu informació d'estat en aquest FD"

	msgid "\|ALGO\|reject signatures made with ALGO"
	msgstr ""

	msgid "Usage: gpgv [options] [files] (-h for help)"
	msgstr "Forma d'ús: gpgv [opcions] [fitxers] (-h per a veure l'ajuda)"

	# Werner FIXME: should it use «Usage»?
	#, fuzzy
	msgid ""
	"Syntax: gpgv [options] [files]\n"
	"Check signatures against known trusted keys\n"
	msgstr ""
	"Sintaxi: gpg [opcions] [fitxers]\n"
	"Comprova signatures amb claus conegudes amb confiança\n"

	msgid "No help available"
	msgstr "No hi ha ajuda disponible"

	#, fuzzy, c-format
	#\| msgid "No help available for `%s'"
	msgid "No help available for '%s'"
	msgstr "No hi ha ajuda disponible per a `%s'"

	msgid "import signatures that are marked as local-only"
	msgstr ""

	msgid "repair damage from the pks keyserver during import"
	msgstr ""

	#, fuzzy
	msgid "do not clear the ownertrust values during import"
	msgstr "actualitza la base de dades de confiança"

	#, fuzzy
	msgid "do not update the trustdb after import"
	msgstr "actualitza la base de dades de confiança"

	#, fuzzy
	msgid "show key during import"
	msgstr "mostra empremta"

	msgid "only accept updates to existing keys"
	msgstr ""

	#, fuzzy
	msgid "remove unusable parts from key after import"
	msgstr "la clau secreta és inusable"

	msgid "remove as much as possible from key after import"
	msgstr ""

	msgid "ignore key-signatures which are not self-signatures"
	msgstr ""

	msgid "run import filters and export key immediately"
	msgstr ""

	msgid "assume the GnuPG key backup format"
	msgstr ""

	#, fuzzy
	msgid "repair keys on import"
	msgstr "mostra empremta"

	#, c-format
	msgid "skipping block of type %d\n"
	msgstr "es descarta un bloc de tipus %d\n"

	#, fuzzy, c-format
	msgid "%lu keys processed so far\n"
	msgstr "fins ara s'han processat %lu claus\n"

	#, c-format
	msgid "Total number processed: %lu\n"
	msgstr "Nombre total processat: %lu\n"

	#, fuzzy, c-format
	#\| msgid " skipped new keys: %lu\n"
	msgid " skipped PGP-2 keys: %lu\n"
	msgstr " claus noves descartades: %lu\n"

	#, c-format
	msgid " skipped new keys: %lu\n"
	msgstr " claus noves descartades: %lu\n"

	#, c-format
	msgid " w/o user IDs: %lu\n"
	msgstr " sense ID: %lu\n"

	#, c-format
	msgid " imported: %lu"
	msgstr " importades: %lu"

	#, c-format
	msgid " unchanged: %lu\n"
	msgstr " no modificades: %lu\n"

	#, c-format
	msgid " new user IDs: %lu\n"
	msgstr " ID d'usuaris nous: %lu\n"

	#, c-format
	msgid " new subkeys: %lu\n"
	msgstr " subclaus noves: %lu\n"

	#, c-format
	msgid " new signatures: %lu\n"
	msgstr " signatures noves: %lu\n"

	#, c-format
	msgid " new key revocations: %lu\n"
	msgstr " noves revocacions: %lu\n"

	#, c-format
	msgid " secret keys read: %lu\n"
	msgstr " claus privades llegides: %lu\n"

	#, c-format
	msgid " secret keys imported: %lu\n"
	msgstr "claus privades importades: %lu\n"

	#, c-format
	msgid " secret keys unchanged: %lu\n"
	msgstr "claus privades no canviades: %lu\n"

	#, c-format
	msgid " not imported: %lu\n"
	msgstr " importades: %lu\n"

	#, fuzzy, c-format
	msgid " signatures cleaned: %lu\n"
	msgstr " signatures noves: %lu\n"

	#, fuzzy, c-format
	msgid " user IDs cleaned: %lu\n"
	msgstr " claus privades llegides: %lu\n"

	#, c-format
	msgid ""
	"WARNING: key %s contains preferences for unavailable\n"
	"algorithms on these user IDs:\n"
	msgstr ""

	#, c-format
	msgid " \"%s\": preference for cipher algorithm %s\n"
	msgstr ""

	#, fuzzy, c-format
	msgid " \"%s\": preference for digest algorithm %s\n"
	msgstr "signatura %s, algorisme de resum %s\n"

	#, c-format
	msgid " \"%s\": preference for compression algorithm %s\n"
	msgstr ""

	#, c-format
	msgid "it is strongly suggested that you update your preferences and\n"
	msgstr ""

	#, c-format
	msgid "re-distribute this key to avoid potential algorithm mismatch problems\n"
	msgstr ""

	#, c-format
	msgid "you can update your preferences with: gpg --edit-key %s updpref save\n"
	msgstr ""

	#, fuzzy, c-format
	msgid "key %s: no user ID\n"
	msgstr "clau %08lX: sense ID\n"

	#, fuzzy, c-format
	msgid "key %s: %s\n"
	msgstr "es descarta «%s»: %s\n"

	msgid "rejected by import screener"
	msgstr ""

	#, fuzzy, c-format
	msgid "key %s: PKS subkey corruption repaired\n"
	msgstr "clau %08lX: corrupció de la subclau HKP reparada\n"

	#, fuzzy, c-format
	msgid "key %s: accepted non self-signed user ID \"%s\"\n"
	msgstr "clau %08lX: s'ha acceptat la ID d'usuari no autosignada «%s»\n"

	#, fuzzy, c-format
	msgid "key %s: no valid user IDs\n"
	msgstr "clau %08lX: l'ID no és vàlid\n"

	#, c-format
	msgid "this may be caused by a missing self-signature\n"
	msgstr "açò pot ser causat per l'absència d'autosignatura\n"

	#, fuzzy, c-format
	msgid "key %s: public key not found: %s\n"
	msgstr "clau %08lX: no s'ha trobat la clau pública: %s\n"

	#, fuzzy, c-format
	msgid "key %s: new key - skipped\n"
	msgstr "clau %08lX: clau nova - es descarta \n"

	#, c-format
	msgid "no writable keyring found: %s\n"
	msgstr "no s'ha trobat cap anell escrivible: %s\n"

	#, fuzzy, c-format
	#\| msgid "error writing keyring `%s': %s\n"
	msgid "error writing keyring '%s': %s\n"
	msgstr "error mentre s'escrivia l'anell «%s»: %s\n"

	#, fuzzy, c-format
	msgid "key %s: public key \"%s\" imported\n"
	msgstr "clau %08lX: s'ha importat la clau pública «%s»\n"

	#, fuzzy, c-format
	msgid "key %s: doesn't match our copy\n"
	msgstr "clau %08lX: no correspon a la nostra còpia\n"

	#, fuzzy, c-format
	msgid "key %s: \"%s\" 1 new user ID\n"
	msgstr "clau %08lX: «%s» 1 ID d'usuari nou\n"

	#, fuzzy, c-format
	msgid "key %s: \"%s\" %d new user IDs\n"
	msgstr "clau %08lX: «%s» %d ID d'usuari nous\n"

	#, fuzzy, c-format
	msgid "key %s: \"%s\" 1 new signature\n"
	msgstr "clau %08lX: «%s» 1 signatura nova\n"

	#, fuzzy, c-format
	msgid "key %s: \"%s\" %d new signatures\n"
	msgstr "clau %08lX: «%s» %d signatures noves\n"

	#, fuzzy, c-format
	msgid "key %s: \"%s\" 1 new subkey\n"
	msgstr "clau %08lX: «%s» 1 subclau nova\n"

	#, fuzzy, c-format
	msgid "key %s: \"%s\" %d new subkeys\n"
	msgstr "clau %08lX: «%s» %d subclaus noves\n"

	#, fuzzy, c-format
	msgid "key %s: \"%s\" %d signature cleaned\n"
	msgstr "clau %08lX: «%s» %d signatures noves\n"

	#, fuzzy, c-format
	msgid "key %s: \"%s\" %d signatures cleaned\n"
	msgstr "clau %08lX: «%s» %d signatures noves\n"

	#, fuzzy, c-format
	msgid "key %s: \"%s\" %d user ID cleaned\n"
	msgstr "clau %08lX: «%s» %d ID d'usuari nous\n"

	#, fuzzy, c-format
	msgid "key %s: \"%s\" %d user IDs cleaned\n"
	msgstr "clau %08lX: «%s» %d ID d'usuari nous\n"

	#, fuzzy, c-format
	msgid "key %s: \"%s\" not changed\n"
	msgstr "clau %08lX: «%s» no ha estat modificada\n"

	#, fuzzy, c-format
	msgid "key %s: secret key imported\n"
	msgstr "clau %08lX: s'ha importat la clau secreta\n"

	#, fuzzy, c-format
	#\| msgid "skipped: secret key already present\n"
	msgid "key %s: secret key already exists\n"
	msgstr "es descarta: la clau secreta ja és present\n"

	#, fuzzy, c-format
	msgid "key %s: error sending to agent: %s\n"
	msgstr "error mentre s'enviava a «%s»: %s\n"

	+#, c-format
	+msgid "key %s: card reference is overridden by key material\n"
	+msgstr ""
	+
	#. TRANSLATORS: For a smartcard, each private key on host has a
	#. * reference (stub) to a smartcard and actual private key data
	#. * is stored on the card. A single smartcard can have up to
	#. * three private key data. Importing private key stub is always
	#. * skipped in 2.1, and it returns GPG_ERR_NOT_PROCESSED.
	#. * Instead, user should be suggested to run 'gpg --card-status',
	#. * then, references to a card will be automatically created
	#. * again.
	#, c-format
	msgid "To migrate '%s', with each smartcard, run: %s\n"
	msgstr ""

	#, fuzzy, c-format
	msgid "secret key %s: %s\n"
	msgstr "no s'ha trobat la clau secreta «%s»: %s\n"

	#, fuzzy, c-format
	msgid "importing secret keys not allowed\n"
	msgstr "s'està escrivint la clau secreta a «%s»\n"

	#, fuzzy, c-format
	msgid "key %s: secret key with invalid cipher %d - skipped\n"
	msgstr "clau %08lX: clau secreta amb xifrat %d no vàlid - es descarta\n"

	msgid "No reason specified"
	msgstr "No s'ha especificat cap raó"

	msgid "Key is superseded"
	msgstr "La clau ha estat substituïda"

	msgid "Key has been compromised"
	msgstr "La clau ha estat compromesa"

	msgid "Key is no longer used"
	msgstr "La clau ja no s'usa"

	msgid "User ID is no longer valid"
	msgstr "L'ID d'usuari ja no és vàlid"

	#, c-format
	msgid "reason for revocation: "
	msgstr "raó de la revocació: "

	#, c-format
	msgid "revocation comment: "
	msgstr "comentari de la revocació: "

	#, fuzzy, c-format
	msgid "key %s: no public key - can't apply revocation certificate\n"
	msgstr ""
	"clau %08lX: falta la clau pública: no es pot aplicar el certificat\n"
	"de revocació\n"

	#, fuzzy, c-format
	msgid "key %s: can't locate original keyblock: %s\n"
	msgstr "clau %08lX: no s'ha trobat el bloc de claus original: %s\n"

	#, fuzzy, c-format
	msgid "key %s: can't read original keyblock: %s\n"
	msgstr "clau %08lX: no s'ha pogut llegir el bloc de claus original: %s\n"

	# O «rebutjara»? ivb
	# Per tots els canvis d'anglicisme «ignorat» -> «es descarta»,
	# «es rebutja» està bé. jm
	#, fuzzy, c-format
	msgid "key %s: invalid revocation certificate: %s - rejected\n"
	msgstr "clau %08lX: el certificat de revocació és invàlid: %s: es rebutja\n"

	#, fuzzy, c-format
	msgid "key %s: \"%s\" revocation certificate imported\n"
	msgstr "clau %08lX: s'ha importat el certificat de revocació «%s»\n"

	#, fuzzy, c-format
	msgid "key %s: no user ID for signature\n"
	msgstr "clau %08lX: no hi ha ID per a la signatura\n"

	#, fuzzy, c-format
	msgid "key %s: unsupported public key algorithm on user ID \"%s\"\n"
	msgstr ""
	"clau %08lX: l'algoritme de clau pública no es suporta sobre l'id d'usuari "
	"«%s»\n"
	"\n"

	#, fuzzy, c-format
	msgid "key %s: invalid self-signature on user ID \"%s\"\n"
	msgstr "clau %08lX: l'autosignatura no és vàlida en l'id d'usuari «%s»\n"

	#, fuzzy, c-format
	msgid "key %s: unsupported public key algorithm\n"
	msgstr "clau %08lX: l'algoritme de clau pública no és suportat\n"

	#, fuzzy, c-format
	msgid "key %s: invalid direct key signature\n"
	msgstr "clau %08lX: s'ha afegit la signatura de clau directa\n"

	#, fuzzy, c-format
	msgid "key %s: no subkey for key binding\n"
	msgstr "clau %08lX: no hi ha una subclau per a l'enllaç de la clau\n"

	#, fuzzy, c-format
	msgid "key %s: invalid subkey binding\n"
	msgstr "clau %08lX: l'enllaç de subclau és invàlid\n"

	#, fuzzy, c-format
	msgid "key %s: removed multiple subkey binding\n"
	msgstr "clau %08lX: s'ha eliminat un enllaç de subclau múltiple\n"

	#, fuzzy, c-format
	msgid "key %s: no subkey for key revocation\n"
	msgstr "clau %08lX: no hi ha una subclau per a la clau de revocació\n"

	#, fuzzy, c-format
	msgid "key %s: invalid subkey revocation\n"
	msgstr "clau %08lX: Subclau de revocació no vàlida\n"

	#, fuzzy, c-format
	msgid "key %s: removed multiple subkey revocation\n"
	msgstr "clau %08lX: s'han eliminat subclaus de revocació múltiples\n"

	#, fuzzy, c-format
	msgid "key %s: skipped user ID \"%s\"\n"
	msgstr "clau %08lX: es descarta l'ID d'usuari '"

	#, fuzzy, c-format
	msgid "key %s: skipped subkey\n"
	msgstr "clau %08lX: es descarta la subclau\n"

	#, fuzzy, c-format
	msgid "key %s: non exportable signature (class 0x%02X) - skipped\n"
	msgstr "clau %08lX: la signatura és inexportable (classe %02x) - es descarta\n"

	#, fuzzy, c-format
	msgid "key %s: revocation certificate at wrong place - skipped\n"
	msgstr ""
	"clau %08lX: el certificat de revocació és en el lloc equivocat - es "
	"descarta\n"

	#, fuzzy, c-format
	msgid "key %s: invalid revocation certificate: %s - skipped\n"
	msgstr "clau %08lX: el certificat de revocació és invàlid: %s - es descarta\n"

	#, fuzzy, c-format
	msgid "key %s: subkey signature in wrong place - skipped\n"
	msgstr ""
	"clau %08lX: la signatura de la subclau és en el lloc equivocat - es "
	"descarta\n"

	#, fuzzy, c-format
	msgid "key %s: unexpected signature class (0x%02X) - skipped\n"
	msgstr ""
	"clau %08lX: la classe de signatura és inesperada (0x%02x) - es descarta\n"

	#, fuzzy, c-format
	msgid "key %s: duplicated user ID detected - merged\n"
	msgstr "clau %08lX: s'ha detectat un ID d'usuari duplicat - es fusiona\n"

	#, fuzzy, c-format
	msgid "WARNING: key %s may be revoked: fetching revocation key %s\n"
	msgstr ""
	"AVÍS: la clau %08lX pot estar revocada: s'adquireix la clau de revocació "
	"%08lX\n"

	#, fuzzy, c-format
	msgid "WARNING: key %s may be revoked: revocation key %s not present.\n"
	msgstr ""
	"AVÍS: la clau %08lX pot estar revocada: la clau de revocació %08lX no està "
	"present.\n"

	#, fuzzy, c-format
	msgid "key %s: \"%s\" revocation certificate added\n"
	msgstr "clau %08lX: s'hi ha afegit el certificat de revocació «%s»\n"

	#, fuzzy, c-format
	msgid "key %s: direct key signature added\n"
	msgstr "clau %08lX: s'ha afegit la signatura de clau directa\n"

	#, fuzzy, c-format
	msgid "error allocating memory: %s\n"
	msgstr "error en crear l'anell «%s»: %s\n"

	#, fuzzy, c-format
	msgid "can't check signature with unsupported public-key algorithm (%d): %s.\n"
	msgstr "clau %08lX: l'algoritme de clau pública no és suportat\n"

	#, fuzzy, c-format
	msgid ""
	"can't check signature with unsupported message-digest algorithm %d: %s.\n"
	msgstr "signatura %s, algorisme de resum %s\n"

	#, fuzzy
	msgid " (reordered signatures follow)"
	msgstr "Signatura correcta de \""

	#, fuzzy, c-format
	msgid "key %s:\n"
	msgstr "es descarta «%s»: %s\n"

	#, fuzzy, c-format
	msgid "%d duplicate signature removed\n"
	msgid_plural "%d duplicate signatures removed\n"
	msgstr[0] "L'ID d'usuari «%s» està revocat."
	msgstr[1] "L'ID d'usuari «%s» està revocat."

	#, fuzzy, c-format
	#\| msgid "1 signature not checked due to a missing key\n"
	msgid "%d signature not checked due to a missing key\n"
	msgid_plural "%d signatures not checked due to missing keys\n"
	msgstr[0] "1 signatura no comprovada per falta de clau\n"
	msgstr[1] "1 signatura no comprovada per falta de clau\n"

	#, fuzzy, c-format
	#\| msgid "%d bad signatures\n"
	msgid "%d bad signature\n"
	msgid_plural "%d bad signatures\n"
	msgstr[0] "%d signatures errònies\n"
	msgstr[1] "%d signatures errònies\n"

	#, fuzzy, c-format
	msgid "%d signature reordered\n"
	msgid_plural "%d signatures reordered\n"
	msgstr[0] "Signatura correcta de \""
	msgstr[1] "Signatura correcta de \""

	#, c-format
	msgid ""
	"Warning: errors found and only checked self-signatures, run '%s' to check "
	"all signatures.\n"
	msgstr ""

	#, fuzzy, c-format
	msgid "error creating keybox '%s': %s\n"
	msgstr "error en crear l'anell «%s»: %s\n"

	#, fuzzy, c-format
	#\| msgid "error creating keyring `%s': %s\n"
	msgid "error creating keyring '%s': %s\n"
	msgstr "error en crear l'anell «%s»: %s\n"

	#, fuzzy, c-format
	msgid "keybox '%s' created\n"
	msgstr "s'ha creat l'anell «%s»\n"

	#, fuzzy, c-format
	#\| msgid "keyring `%s' created\n"
	msgid "keyring '%s' created\n"
	msgstr "s'ha creat l'anell «%s»\n"

	#, fuzzy, c-format
	msgid "keyblock resource '%s': %s\n"
	msgstr "error en crear «%s»: %s\n"

	#, fuzzy, c-format
	msgid "error opening key DB: %s\n"
	msgstr "error en la lectura de «%s»: %s\n"

	#, c-format
	msgid "failed to rebuild keyring cache: %s\n"
	msgstr "no s'ha pogut reconstruir la memòria cau de l'anell: %s\n"

	msgid "[revocation]"
	msgstr "[revocació]"

	msgid "[self-signature]"
	msgstr "[autosignatura]"

	#, fuzzy
	msgid ""
	"Please decide how far you trust this user to correctly verify other users' "
	"keys\n"
	"(by looking at passports, checking fingerprints from different sources, "
	"etc.)\n"
	msgstr ""
	"Decidiu fins a quin punt confieu en aquest usuari per a\n"
	"verificar les claus d'altres usuaris (mirant passaports,\n"
	"comprovant empremtes de diferents fonts...)?\n"

	#, fuzzy, c-format
	msgid " %d = I trust marginally\n"
	msgstr " %d = Hi confie marginalment\n"

	#, fuzzy, c-format
	msgid " %d = I trust fully\n"
	msgstr " %d = Hi confie plenament\n"

	msgid ""
	"Please enter the depth of this trust signature.\n"
	"A depth greater than 1 allows the key you are signing to make\n"
	"trust signatures on your behalf.\n"
	msgstr ""

	msgid "Please enter a domain to restrict this signature, or enter for none.\n"
	msgstr ""

	#, c-format
	msgid "Skipping user ID \"%s\", which is not a text ID.\n"
	msgstr ""

	#, c-format
	msgid "User ID \"%s\" is revoked."
	msgstr "L'ID d'usuari «%s» està revocat."

	msgid "Are you sure you still want to sign it? (y/N) "
	msgstr "Segur que encara voleu signarla? (s/N) "

	# O no s'ha pogut? ivb
	# FIXME: comprovar context. jm
	msgid " Unable to sign.\n"
	msgstr " No es pot signar.\n"

	#, c-format
	msgid "User ID \"%s\" is expired."
	msgstr "L'ID d'usuari «%s» ha caducat."

	#, c-format
	msgid "User ID \"%s\" is not self-signed."
	msgstr "L'ID d'usuari «%s» no està autosignat."

	#, fuzzy, c-format
	msgid "User ID \"%s\" is signable. "
	msgstr "L'ID d'usuari «%s» no està autosignat."

	#, fuzzy
	msgid "Sign it? (y/N) "
	msgstr "Signar realment? "

	#, c-format
	msgid ""
	"The self-signature on \"%s\"\n"
	"is a PGP 2.x-style signature.\n"
	msgstr ""
	"La vostra signatura en «%s»\n"
	"és una signatura d'estil PGP 2.x.\n"

	msgid "Do you want to promote it to an OpenPGP self-signature? (y/N) "
	msgstr "Voleu ascendir-la a una autosignatura OpenPGP? (s/N) "

	#, c-format
	msgid ""
	"Your current signature on \"%s\"\n"
	"has expired.\n"
	msgstr ""
	"La vostra signatura actual en «%s»\n"
	"ha caducat.\n"

	msgid "Do you want to issue a new signature to replace the expired one? (y/N) "
	msgstr "Voleu crear una nova signatura per a reemplaçar la caducada? (s/N) "

	#, c-format
	msgid ""
	"Your current signature on \"%s\"\n"
	"is a local signature.\n"
	msgstr ""
	"La vostra signatura en «%s»\n"
	"és una signatura local.\n"

	msgid "Do you want to promote it to a full exportable signature? (y/N) "
	msgstr "Voleu ascendir-la a una signatura completament exportable? (s/N) "

	#, fuzzy, c-format
	msgid "\"%s\" was already locally signed by key %s\n"
	msgstr "«%s» ja estava signada localment amb la clau %08lX\n"

	#, fuzzy, c-format
	msgid "\"%s\" was already signed by key %s\n"
	msgstr "«%s» ja estava signada amb la clau %08lX\n"

	msgid "Do you want to sign it again anyway? (y/N) "
	msgstr "Voleu signarla un altre cop, de tota manera? (s/N) "

	#, fuzzy, c-format
	msgid "Nothing to sign with key %s\n"
	msgstr "No hi ha res que signar amb la clau %08lX\n"

	msgid "This key has expired!"
	msgstr "La clau ha caducat!"

	#, c-format
	msgid "This key is due to expire on %s.\n"
	msgstr "Aquesta clau caducarà el %s.\n"

	msgid "Do you want your signature to expire at the same time? (Y/n) "
	msgstr "Voleu que la vostra signatura caduque alhora? (S/n) "

	msgid ""
	"How carefully have you verified the key you are about to sign actually "
	"belongs\n"
	"to the person named above? If you don't know what to answer, enter \"0\".\n"
	msgstr ""
	"Amb quanta cura heu verificat que la clau que esteu a punt de signar \n"
	"pertany realment a la persona esmentada anteriorment? Si no sabeu què \n"
	"contestar, entreu «0».\n"

	#, c-format
	msgid " (0) I will not answer.%s\n"
	msgstr " (0) No vaig a contestar.%s\n"

	#, c-format
	msgid " (1) I have not checked at all.%s\n"
	msgstr " (1) No ho he comprovat en absolut.%s\n"

	#, c-format
	msgid " (2) I have done casual checking.%s\n"
	msgstr " (2) He fet algunes comprovacions.%s\n"

	#, c-format
	msgid " (3) I have done very careful checking.%s\n"
	msgstr " (3) He fet comprovacions molt acurades.%s\n"

	#, fuzzy
	msgid "Your selection? (enter '?' for more information): "
	msgstr "Seleccioneu una opció (introduïu «?» per obtindre més informació):"

	#, fuzzy, c-format
	msgid ""
	"Are you sure that you want to sign this key with your\n"
	"key \"%s\" (%s)\n"
	msgstr ""
	"Esteu segur que voleu signar aquesta clau\n"
	"amb la vostra clau: \""

	#, fuzzy
	msgid "This will be a self-signature.\n"
	msgstr ""
	"\n"
	"Açò serà una autosignatura.\n"

	#, fuzzy
	msgid "WARNING: the signature will not be marked as non-exportable.\n"
	msgstr ""
	"\n"
	"AVÍS: la signatura no es marcarà com a inexportable.\n"

	#, fuzzy
	msgid "WARNING: the signature will not be marked as non-revocable.\n"
	msgstr ""
	"\n"
	"AVÍS: la signatura no es marcarà com a irrevocable.\n"

	#, fuzzy
	msgid "The signature will be marked as non-exportable.\n"
	msgstr ""
	"\n"
	"La signatura es marcarà com a inexportable.\n"

	#, fuzzy
	msgid "The signature will be marked as non-revocable.\n"
	msgstr ""
	"\n"
	"La signatura es marcarà com a irrevocable.\n"

	#, fuzzy
	msgid "I have not checked this key at all.\n"
	msgstr ""
	"\n"
	"No he comprovat aquesta clau en absolut.\n"

	#, fuzzy
	msgid "I have checked this key casually.\n"
	msgstr ""
	"\n"
	"He fet algunes comprovacions a aquesta clau.\n"

	#, fuzzy
	msgid "I have checked this key very carefully.\n"
	msgstr ""
	"\n"
	"He comprovat aquesta clau amb molta cura.\n"

	#, fuzzy
	msgid "Really sign? (y/N) "
	msgstr "Signar realment? "

	#, c-format
	msgid "signing failed: %s\n"
	msgstr "Ha fallat el procés de signatura: %s\n"

	msgid "Key has only stub or on-card key items - no passphrase to change.\n"
	msgstr ""

	#, fuzzy, c-format
	#\| msgid "error creating passphrase: %s\n"
	msgid "key %s: error changing passphrase: %s\n"
	msgstr "error en la creació de la contrasenya: %s\n"

	msgid "save and quit"
	msgstr "desa i ix"

	#, fuzzy
	msgid "show key fingerprint"
	msgstr "mostra empremta"

	#, fuzzy
	msgid "show the keygrip"
	msgstr "Notació de signatura: "

	msgid "list key and user IDs"
	msgstr "llista claus i ID"

	# Per aquesta zona (keyedit) hi ha un cacau d'infinitius i presents... ivb
	# Yeah, els vaig corregir abans de que enviares la teua correcció. jm
	msgid "select user ID N"
	msgstr "tria l'ID d'usuari N"

	# Per aquesta zona (keyedit) hi ha un cacau d'infinitius i presents... ivb
	# Yeah, els vaig corregir abans de que enviares la teua correcció. jm
	#, fuzzy
	msgid "select subkey N"
	msgstr "tria l'ID d'usuari N"

	#, fuzzy
	msgid "check signatures"
	msgstr "revoca signatures"

	msgid "sign selected user IDs [* see below for related commands]"
	msgstr ""

	#, fuzzy
	msgid "sign selected user IDs locally"
	msgstr "signa la clau localment"

	#, fuzzy
	msgid "sign selected user IDs with a trust signature"
	msgstr "Pista: Trieu els ID d'usuari que voleu signar\n"

	msgid "sign selected user IDs with a non-revocable signature"
	msgstr ""

	msgid "add a user ID"
	msgstr "afegeix un ID d'usuari"

	# Com estava escrit abans. ivb
	# Si et refereixes a Photo vs. photo, ho deixe en minúscules, que en tot
	# el menú està tot en minúscules. Tb hi ha molts ID vs. id en els msgids
	# i no hem unificat en català. Potser li ho diré a Werner. jm.
	msgid "add a photo ID"
	msgstr "afegeix un photo ID"

	#, fuzzy
	msgid "delete selected user IDs"
	msgstr "esborra un ID d'usuari"

	#, fuzzy
	msgid "add a subkey"
	msgstr "addkey"

	msgid "add a key to a smartcard"
	msgstr ""

	msgid "move a key to a smartcard"
	msgstr ""

	msgid "move a backup key to a smartcard"
	msgstr ""

	#, fuzzy
	msgid "delete selected subkeys"
	msgstr "esborra una clau secundària"

	msgid "add a revocation key"
	msgstr "afegeix una clau de revocació"

	#, fuzzy
	msgid "delete signatures from the selected user IDs"
	msgstr ""
	"Voleu actualitzar les preferències per a les ID d'usuaris seleccionades?"

	#, fuzzy
	msgid "change the expiration date for the key or selected subkeys"
	msgstr "No podeu canviar la data de caducitat de les claus v3\n"

	#, fuzzy
	msgid "flag the selected user ID as primary"
	msgstr "marca l'ID d'usuari com a primari"

	msgid "list preferences (expert)"
	msgstr "llista les preferències (expert)"

	msgid "list preferences (verbose)"
	msgstr "llista les preferències (detallat)"

	#, fuzzy
	msgid "set preference list for the selected user IDs"
	msgstr ""
	"Voleu actualitzar les preferències per a les ID d'usuaris seleccionades?"

	#, fuzzy
	msgid "set the preferred keyserver URL for the selected user IDs"
	msgstr "no s'ha pogut analitzar sintàcticament la URI del servidor de claus\n"

	#, fuzzy
	msgid "set a notation for the selected user IDs"
	msgstr ""
	"Voleu actualitzar les preferències per a les ID d'usuaris seleccionades?"

	msgid "change the passphrase"
	msgstr "canvia la contrasenya"

	msgid "change the ownertrust"
	msgstr "canvia la confiança"

	#, fuzzy
	msgid "revoke signatures on the selected user IDs"
	msgstr "Realment voleu revocar tots els ID d'usuari seleccionats? "

	#, fuzzy
	msgid "revoke selected user IDs"
	msgstr "revoca un ID d'usuari"

	#, fuzzy
	msgid "revoke key or selected subkeys"
	msgstr "revoca una clau secundària"

	#, fuzzy
	msgid "enable key"
	msgstr "activa una clau"

	#, fuzzy
	msgid "disable key"
	msgstr "desactiva una clau"

	# Igual que dalt. ivb
	# Idem :) jm
	#, fuzzy
	msgid "show selected photo IDs"
	msgstr "mostra el photo ID"

	msgid "compact unusable user IDs and remove unusable signatures from key"
	msgstr ""

	msgid "compact unusable user IDs and remove all signatures from key"
	msgstr ""

	msgid "Secret key is available.\n"
	msgstr "La clau secreta està disponible.\n"

	#, fuzzy
	#\| msgid "Secret key is available.\n"
	msgid "Secret subkeys are available.\n"
	msgstr "La clau secreta està disponible.\n"

	+msgid ""
	+"Note: the local copy of the secret key will only be deleted with \"save\".\n"
	+msgstr ""
	+
	msgid "Need the secret key to do this.\n"
	msgstr "Cal la clau secreta per a fer açò.\n"

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

	msgid "Key is revoked."
	msgstr "La clau està revocada."

	#, fuzzy
	msgid "Really sign all text user IDs? (y/N) "
	msgstr "Realment voleu signar tots els ID d'usuari? "

	#, fuzzy
	msgid "Really sign all user IDs? (y/N) "
	msgstr "Realment voleu signar tots els ID d'usuari? "

	msgid "Hint: Select the user IDs to sign\n"
	msgstr "Pista: Trieu els ID d'usuari que voleu signar\n"

	#, fuzzy, c-format
	msgid "Unknown signature type '%s'\n"
	msgstr "la classe de signatura és desconeguda"

	msgid "You must select at least one user ID.\n"
	msgstr "Heu de seleccionar al menys un ID d'usuari.\n"

	#, c-format
	msgid "(Use the '%s' command.)\n"
	msgstr ""

	msgid "You can't delete the last user ID!\n"
	msgstr "No podeu esborrar l'últim ID d'usuari!\n"

	#, fuzzy
	msgid "Really remove all selected user IDs? (y/N) "
	msgstr "Realment voleu eliminar tots els ID d'usuari seleccionats? "

	#, fuzzy
	msgid "Really remove this user ID? (y/N) "
	msgstr "Realment voleu eliminar aquest ID d'usuari? "

	#. TRANSLATORS: Please take care: This is about
	#. moving the key and not about removing it.
	#, fuzzy
	msgid "Really move the primary key? (y/N) "
	msgstr "Realment voleu esborrar aquesta autosignatura? (s/N)"

	#, fuzzy
	msgid "You must select exactly one key.\n"
	msgstr "Heu de seleccionar, si més no, una clau.\n"

	msgid "Command expects a filename argument\n"
	msgstr ""

	#, fuzzy, c-format
	msgid "Can't open '%s': %s\n"
	msgstr "no s'ha pogut obrir «%s»: %s\n"

	#, fuzzy, c-format
	msgid "Error reading backup key from '%s': %s\n"
	msgstr "error en crear l'anell «%s»: %s\n"

	msgid "You must select at least one key.\n"
	msgstr "Heu de seleccionar, si més no, una clau.\n"

	#, fuzzy
	msgid "Do you really want to delete the selected keys? (y/N) "
	msgstr "Realment voleu eliminar les claus seleccionades? "

	#, fuzzy
	msgid "Do you really want to delete this key? (y/N) "
	msgstr "Realment voleu eliminar aquesta clau? "

	#, fuzzy
	msgid "Really revoke all selected user IDs? (y/N) "
	msgstr "Realment voleu revocar tots els ID d'usuari seleccionats? "

	#, fuzzy
	msgid "Really revoke this user ID? (y/N) "
	msgstr "Realment voleu eliminar aquest ID d'usuari? "

	#, fuzzy
	msgid "Do you really want to revoke the entire key? (y/N) "
	msgstr "Realment voleu revocar aquesta clau? "

	#, fuzzy
	msgid "Do you really want to revoke the selected subkeys? (y/N) "
	msgstr "Realment voleu revocar les claus seleccionades? "

	#, fuzzy
	msgid "Do you really want to revoke this subkey? (y/N) "
	msgstr "Realment voleu revocar aquesta clau? "

	msgid "Owner trust may not be set while using a user provided trust database\n"
	msgstr ""

	#, fuzzy
	msgid "Set preference list to:\n"
	msgstr "estableix la llista de preferències"

	#, fuzzy
	msgid "Really update the preferences for the selected user IDs? (y/N) "
	msgstr ""
	"Voleu actualitzar les preferències per a les ID d'usuaris seleccionades?"

	#, fuzzy
	msgid "Really update the preferences? (y/N) "
	msgstr "Realment voleu actualitzar les preferències? "

	#, fuzzy
	msgid "Save changes? (y/N) "
	msgstr "Voleu desar els canvis? "

	#, fuzzy
	msgid "Quit without saving? (y/N) "
	msgstr "Voleu eixir sense desar? "

	+#, fuzzy, c-format
	+msgid "deleting copy of secret key failed: %s\n"
	+msgstr "no s'ha pogut eliminar el bloc de claus: %s\n"
	+
	#, c-format
	msgid "Key not changed so no update needed.\n"
	msgstr "La clau no ha canviat, per tant no cal actualització.\n"

	#, fuzzy, c-format
	#\| msgid "You can't delete the last user ID!\n"
	msgid "cannot revoke the last valid user ID.\n"
	msgstr "No podeu esborrar l'últim ID d'usuari!\n"

	#, fuzzy, c-format
	msgid "revoking the user ID failed: %s\n"
	msgstr "no s'ha pogut comprovar la signatura creada: %s\n"

	#, fuzzy, c-format
	msgid "setting the primary user ID failed: %s\n"
	msgstr "no s'ha pogut comprovar la signatura creada: %s\n"

	#, fuzzy, c-format
	msgid "\"%s\" is not a fingerprint\n"
	msgstr "error: l'empremta digital és invàlida\n"

	#, fuzzy, c-format
	msgid "\"%s\" is not the primary fingerprint\n"
	msgstr "no s'ha pogut emmagatzemar l'empremta digital: %s\n"

	#, fuzzy, c-format
	#\| msgid "invalid value\n"
	msgid "Invalid user ID '%s': %s\n"
	msgstr "el valor no és vàlid\n"

	#, fuzzy
	#\| msgid "No such user ID.\n"
	msgid "No matching user IDs."
	msgstr "Usuari inexistent.\n"

	#, fuzzy
	msgid "Nothing to sign.\n"
	msgstr "No hi ha res que signar amb la clau %08lX\n"

	#, c-format
	msgid "Not signed by you.\n"
	msgstr ""

	#, fuzzy, c-format
	#\| msgid "checking created signature failed: %s\n"
	msgid "revoking the key signature failed: %s\n"
	msgstr "no s'ha pogut comprovar la signatura creada: %s\n"

	#, fuzzy, c-format
	msgid "'%s' is not a valid expiration time\n"
	msgstr "%s no és un joc de caràcters vàlid\n"

	#, fuzzy, c-format
	msgid "\"%s\" is not a proper fingerprint\n"
	msgstr "error: l'empremta digital és invàlida\n"

	#, fuzzy, c-format
	msgid "subkey \"%s\" not found\n"
	msgstr "no s'ha trobat la clau «%s»: %s\n"

	msgid "Preferred keyserver: "
	msgstr ""

	#, fuzzy
	msgid "Notations: "
	msgstr "Notació: "

	msgid "There are no preferences on a PGP 2.x-style user ID.\n"
	msgstr "No hi ha preferències en un ID d'usuari d'estil PGP 2.x.\n"

	# Potser %s haja d'anar darrere de «clau». ivb
	# És cert. Nova funcionalitat de 1.2.0, IIRC. jm
	#, fuzzy, c-format
	msgid "The following key was revoked on %s by %s key %s\n"
	msgstr "Aquesta clau pot ser revocada per la clau %s "

	# Potser %s haja d'anar darrere de «clau». ivb
	# És cert. Nova funcionalitat de 1.2.0, IIRC. jm
	#, fuzzy, c-format
	msgid "This key may be revoked by %s key %s"
	msgstr "Aquesta clau pot ser revocada per la clau %s "

	#, fuzzy
	msgid "(sensitive)"
	msgstr " (sensible)"

	#, fuzzy, c-format
	msgid "created: %s"
	msgstr "no s'ha pogut creat %s: %s\n"

	#, fuzzy, c-format
	msgid "revoked: %s"
	msgstr "[revocada]"

	#, fuzzy, c-format
	msgid "expired: %s"
	msgstr " [caduca: %s]"

	#, fuzzy, c-format
	msgid "expires: %s"
	msgstr " [caduca: %s]"

	#, c-format
	msgid "usage: %s"
	msgstr ""

	msgid "card-no: "
	msgstr ""

	#, fuzzy, c-format
	msgid "trust: %s"
	msgstr " confiança: %c/%c"

	#, c-format
	msgid "validity: %s"
	msgstr ""

	msgid "This key has been disabled"
	msgstr "Aquesta clau ha estat desactivada"

	msgid ""
	"Please note that the shown key validity is not necessarily correct\n"
	"unless you restart the program.\n"
	msgstr ""
	"Teniu en compte que la validesa de la clau mostrada no és necessàriament\n"
	"correcta a no ser que torneu a executar el programa.\n"

	#, fuzzy
	msgid "revoked"
	msgstr "[revocada]"

	#, fuzzy
	msgid "expired"
	msgstr "expire"

	#, c-format
	msgid ""
	"WARNING: no user ID has been marked as primary. This command may\n"
	" cause a different user ID to become the assumed primary.\n"
	msgstr ""
	"AVÍS: no s'ha marcat cap ID d'usuari com primària. Aquesta ordre pot\n"
	" causar que una ID d'usuari diferent esdevinga en la primària "
	"assumida.\n"

	#, c-format
	msgid "WARNING: Your encryption subkey expires soon.\n"
	msgstr ""

	#, fuzzy, c-format
	#\| msgid "You can't change the expiration date of a v3 key\n"
	msgid "You may want to change its expiration date too.\n"
	msgstr "No podeu canviar la data de caducitat de les claus v3\n"

	# Photo ID com abans. ivb
	msgid ""
	"WARNING: This is a PGP2-style key. Adding a photo ID may cause some "
	"versions\n"
	" of PGP to reject this key.\n"
	msgstr ""
	"AVÍS: Aquesta és una clau d'estil PGP2. Afegir un photo ID pot fer que "
	"algunes versions de PGP rebutgen aquesta clau.\n"

	msgid "Are you sure you still want to add it? (y/N) "
	msgstr "Esteu segur que encara voleu afegir-lo? (s/N) "

	msgid "You may not add a photo ID to a PGP2-style key.\n"
	msgstr "No podeu afegir un photo ID a una clau d'estil PGP2.\n"

	msgid "Such a user ID already exists on this key!\n"
	msgstr ""

	# Aquesta i les següents no haurien de portar (s/N/q) i no (y/N/q)? ivb
	# Hmm. Sí... (s/N/x) jm
	msgid "Delete this good signature? (y/N/q)"
	msgstr "Voleu esborrar aquesta signatura correcta? (s/N/x)"

	msgid "Delete this invalid signature? (y/N/q)"
	msgstr "Voleu esborrar aquesta signatura invàlida? (s/N/x)"

	msgid "Delete this unknown signature? (y/N/q)"
	msgstr "Voleu esborrar aquesta signatura desconeguda? (s/N/x)"

	msgid "Really delete this self-signature? (y/N)"
	msgstr "Realment voleu esborrar aquesta autosignatura? (s/N)"

	# Werner FIXME: use ngettext. jm
	#, fuzzy, c-format
	#\| msgid "Deleted %d signature.\n"
	msgid "Deleted %d signature.\n"
	msgid_plural "Deleted %d signatures.\n"
	msgstr[0] "S'ha esborrat %d signatura.\n"
	msgstr[1] "S'ha esborrat %d signatura.\n"

	msgid "Nothing deleted.\n"
	msgstr "No s'hi ha eliminat res.\n"

	msgid "invalid"
	msgstr "invàlida"

	#, fuzzy, c-format
	msgid "User ID \"%s\" compacted: %s\n"
	msgstr "L'ID d'usuari «%s» està revocat."

	#, fuzzy, c-format
	msgid "User ID \"%s\": %d signature removed\n"
	msgid_plural "User ID \"%s\": %d signatures removed\n"
	msgstr[0] "L'ID d'usuari «%s» està revocat."
	msgstr[1] "L'ID d'usuari «%s» està revocat."

	#, fuzzy, c-format
	msgid "User ID \"%s\": already minimized\n"
	msgstr "l'ID d'usuari «%s» ja està revocat\n"

	#, fuzzy, c-format
	msgid "User ID \"%s\": already clean\n"
	msgstr "l'ID d'usuari «%s» ja està revocat\n"

	msgid ""
	"WARNING: This is a PGP 2.x-style key. Adding a designated revoker may "
	"cause\n"
	" some versions of PGP to reject this key.\n"
	msgstr ""
	"AVÍS: Aquesta és una clau d'estil PGP 2.x. Afegir un revocador designat pot\n"
	"fer que algunes versions de PGP rebutjen aquesta clau.\n"

	msgid "You may not add a designated revoker to a PGP 2.x-style key.\n"
	msgstr "No podeu afegir un revocador designat a una clau d'estil PGP 2.x.\n"

	msgid "Enter the user ID of the designated revoker: "
	msgstr "Introduïu l'ID d'usuari del revocador designat: "

	#, c-format
	msgid "cannot appoint a PGP 2.x style key as a designated revoker\n"
	msgstr ""
	"no es pot nominar a una clau d'estil PGP 2.x com a revocador designat\n"

	#, c-format
	msgid "you cannot appoint a key as its own designated revoker\n"
	msgstr "no podeu nominar una clau com el seu propi revocador designat\n"

	#, fuzzy, c-format
	msgid "this key has already been designated as a revoker\n"
	msgstr "no podeu nominar una clau com el seu propi revocador designat\n"

	msgid "WARNING: appointing a key as a designated revoker cannot be undone!\n"
	msgstr ""
	"AVÍS: no es pot desfer la nominació d'una clau com a revocador designat!\n"

	#, fuzzy
	msgid ""
	"Are you sure you want to appoint this key as a designated revoker? (y/N) "
	msgstr ""
	"Esteu segur que voleu nominar aquesta clau com a revocador designat? (s/N): "

	#, fuzzy
	msgid ""
	"Are you sure you want to change the expiration time for multiple subkeys? (y/"
	"N) "
	msgstr ""
	"Esteu segur que voleu nominar aquesta clau com a revocador designat? (s/N): "

	#, fuzzy
	msgid "Changing expiration time for a subkey.\n"
	msgstr "S'està canviant la data de caducitat per a una clau secundària.\n"

	msgid "Changing expiration time for the primary key.\n"
	msgstr "S'està canviant la data de caducitat per a una clau primària.\n"

	#, c-format
	msgid "You can't change the expiration date of a v3 key\n"
	msgstr "No podeu canviar la data de caducitat de les claus v3\n"

	#, fuzzy
	msgid "Changing usage of a subkey.\n"
	msgstr "S'està canviant la data de caducitat per a una clau secundària.\n"

	#, fuzzy
	#\| msgid "Changing expiration time for the primary key.\n"
	msgid "Changing usage of the primary key.\n"
	msgstr "S'està canviant la data de caducitat per a una clau primària.\n"

	#, fuzzy, c-format
	msgid "signing subkey %s is already cross-certified\n"
	msgstr ""
	"AVÍS: no es pot desfer la nominació d'una clau com a revocador designat!\n"

	#, c-format
	msgid "subkey %s does not sign and so does not need to be cross-certified\n"
	msgstr ""

	msgid "Please select exactly one user ID.\n"
	msgstr "Heu de seleccionar exactament un ID.\n"

	#, fuzzy, c-format
	msgid "skipping v3 self-signature on user ID \"%s\"\n"
	msgstr "es descarta l'autosignatura v3 en l'id d'usuari «%s»\n"

	msgid "Enter your preferred keyserver URL: "
	msgstr ""

	#, fuzzy
	msgid "Are you sure you want to replace it? (y/N) "
	msgstr "Esteu segur que encara voleu utilitzarla (s/N)? "

	#, fuzzy
	msgid "Are you sure you want to delete it? (y/N) "
	msgstr "Esteu segur que encara voleu utilitzarla (s/N)? "

	#, fuzzy
	msgid "Enter the notation: "
	msgstr "Notació de signatura: "

	#, fuzzy
	msgid "Proceed? (y/N) "
	msgstr "Voleu sobreescriure? (s/N) "

	#, c-format
	msgid "No user ID with index %d\n"
	msgstr "No hi ha cap ID amb l'índex %d\n"

	#, fuzzy, c-format
	msgid "No user ID with hash %s\n"
	msgstr "No hi ha cap ID amb l'índex %d\n"

	#, fuzzy, c-format
	msgid "No subkey with key ID '%s'.\n"
	msgstr "No hi ha cap ID amb l'índex %d\n"

	#, fuzzy, c-format
	msgid "No subkey with index %d\n"
	msgstr "No hi ha cap ID amb l'índex %d\n"

	#, fuzzy, c-format
	msgid "user ID: \"%s\"\n"
	msgstr "ID d'usuari: «"

	#, fuzzy, c-format
	msgid "signed by your key %s on %s%s%s\n"
	msgstr ""
	"»\n"
	"signat amb la vostra clau %08lX el %s\n"

	msgid " (non-exportable)"
	msgstr " (no-exportable)"

	#, c-format
	msgid "This signature expired on %s.\n"
	msgstr "Aquesta signatura va caducar el %s.\n"

	msgid "Are you sure you still want to revoke it? (y/N) "
	msgstr "Esteu segur de que encara voleu revocarla? (s/N) "

	# (s/N) ivb
	# S! jm
	msgid "Create a revocation certificate for this signature? (y/N) "
	msgstr "Voleu crear un certificat de revocació per a aquesta signatura? (s/N) "

	#, fuzzy, c-format
	msgid "You have signed these user IDs on key %s:\n"
	msgstr "Heu signat els següents ID d'usuari:\n"

	#, fuzzy
	msgid " (non-revocable)"
	msgstr " (no-exportable)"

	#, fuzzy, c-format
	msgid "revoked by your key %s on %s\n"
	msgstr " revocat per %08lX el %s\n"

	msgid "You are about to revoke these signatures:\n"
	msgstr "Esteu a punt de revocar aquestes signatures:\n"

	# (s/N)? ivb
	msgid "Really create the revocation certificates? (y/N) "
	msgstr "Realment voleu crear els certificats de revocació? (s/N) "

	#, c-format
	msgid "no secret key\n"
	msgstr "ho hi ha clau secreta\n"

	#, c-format
	msgid "tried to revoke a non-user ID: %s\n"
	msgstr ""

	#, c-format
	msgid "user ID \"%s\" is already revoked\n"
	msgstr "l'ID d'usuari «%s» ja està revocat\n"

	#, c-format
	msgid "WARNING: a user ID signature is dated %d seconds in the future\n"
	msgstr "AVÍS: una signatura d'ID d'usuari està datada %d segons en el futur\n"

	#, fuzzy, c-format
	#\| msgid "You can't delete the last user ID!\n"
	msgid "Cannot revoke the last valid user ID.\n"
	msgstr "No podeu esborrar l'últim ID d'usuari!\n"

	#, fuzzy, c-format
	msgid "Key %s is already revoked.\n"
	msgstr "l'ID d'usuari «%s» ja està revocat\n"

	#, fuzzy, c-format
	msgid "Subkey %s is already revoked.\n"
	msgstr "l'ID d'usuari «%s» ja està revocat\n"

	#, fuzzy, c-format
	msgid "Displaying %s photo ID of size %ld for key %s (uid %d)\n"
	msgstr ""
	"S'està mostrant el photo ID %s de mida %ld per a la clau 0x%08lX (uid %d)\n"

	#, fuzzy, c-format
	msgid "invalid value for option '%s'\n"
	msgstr "opcions d'importació no vàlides\n"

	#, fuzzy, c-format
	msgid "preference '%s' duplicated\n"
	msgstr "la preferència %c%lu és duplicada\n"

	#, fuzzy, c-format
	msgid "too many cipher preferences\n"
	msgstr "hi ha massa preferències «%c»\n"

	#, fuzzy, c-format
	msgid "too many digest preferences\n"
	msgstr "hi ha massa preferències «%c»\n"

	#, fuzzy, c-format
	msgid "too many compression preferences\n"
	msgstr "hi ha massa preferències «%c»\n"

	#, fuzzy, c-format
	msgid "invalid item '%s' in preference string\n"
	msgstr "hi ha un caràcter invàlid en la cadena de preferència\n"

	#, c-format
	msgid "writing direct signature\n"
	msgstr "s'està escrivint una signatura directa\n"

	#, c-format
	msgid "writing self signature\n"
	msgstr "s'està escrivint l'autosignatura\n"

	#, c-format
	msgid "writing key binding signature\n"
	msgstr "s'està escrivint la signatura de comprovació de la clau\n"

	#, c-format
	msgid "keysize invalid; using %u bits\n"
	msgstr "la mida de la clau és invàlida; s'hi usaran %u bits\n"

	#, c-format
	msgid "keysize rounded up to %u bits\n"
	msgstr "la mida de la clau ha estat arrodonida fins a %u bits\n"

	#, c-format
	msgid ""
	"WARNING: some OpenPGP programs can't handle a DSA key with this digest size\n"
	msgstr ""

	#, fuzzy
	msgid "Sign"
	msgstr "sign"

	msgid "Certify"
	msgstr ""

	#, fuzzy
	msgid "Encrypt"
	msgstr "xifra dades"

	msgid "Authenticate"
	msgstr ""

	#. TRANSLATORS: Please use only plain ASCII characters for the
	#. * translation. If this is not possible use single digits. The
	#. * string needs to 8 bytes long. Here is a description of the
	#. * functions:
	#. *
	#. * s = Toggle signing capability
	#. * e = Toggle encryption capability
	#. * a = Toggle authentication capability
	#. * q = Finish
	#.
	msgid "SsEeAaQq"
	msgstr ""

	#, c-format
	msgid "Possible actions for a %s key: "
	msgstr ""

	msgid "Current allowed actions: "
	msgstr ""

	#, c-format
	msgid " (%c) Toggle the sign capability\n"
	msgstr ""

	#, c-format
	msgid " (%c) Toggle the encrypt capability\n"
	msgstr ""

	#, c-format
	msgid " (%c) Toggle the authenticate capability\n"
	msgstr ""

	#, c-format
	msgid " (%c) Finished\n"
	msgstr ""

	#, fuzzy, c-format
	msgid " (%d) RSA and RSA (default)\n"
	msgstr " (%d) DSA i ElGamal (predeterminat)\n"

	#, fuzzy, c-format
	msgid " (%d) DSA and Elgamal\n"
	msgstr " (%d) DSA i ElGamal (predeterminat)\n"

	#, c-format
	msgid " (%d) DSA (sign only)\n"
	msgstr " (%d) DSA (només signar)\n"

	#, c-format
	msgid " (%d) RSA (sign only)\n"
	msgstr " (%d) RSA (només signar)\n"

	#, fuzzy, c-format
	msgid " (%d) Elgamal (encrypt only)\n"
	msgstr " (%d) ElGamal (només xifrar)\n"

	#, c-format
	msgid " (%d) RSA (encrypt only)\n"
	msgstr " (%d) RSA (només xifrar)\n"

	#, fuzzy, c-format
	msgid " (%d) DSA (set your own capabilities)\n"
	msgstr " (%d) DSA (només signar)\n"

	#, fuzzy, c-format
	msgid " (%d) RSA (set your own capabilities)\n"
	msgstr " (%d) RSA (només xifrar)\n"

	#, fuzzy, c-format
	msgid " (%d) ECC and ECC\n"
	msgstr " (%d) DSA i ElGamal (predeterminat)\n"

	#, fuzzy, c-format
	#\| msgid " (%d) DSA (sign only)\n"
	msgid " (%d) ECC (sign only)\n"
	msgstr " (%d) DSA (només signar)\n"

	#, fuzzy, c-format
	msgid " (%d) ECC (set your own capabilities)\n"
	msgstr " (%d) DSA (només signar)\n"

	#, fuzzy, c-format
	#\| msgid " (%d) RSA (encrypt only)\n"
	msgid " (%d) ECC (encrypt only)\n"
	msgstr " (%d) RSA (només xifrar)\n"

	#, fuzzy, c-format
	msgid " (%d) Existing key\n"
	msgstr " (%d) RSA (només xifrar)\n"

	#, fuzzy, c-format
	msgid " (%d) Existing key from card\n"
	msgstr " (%d) RSA (només xifrar)\n"

	#, fuzzy
	msgid "Enter the keygrip: "
	msgstr "Notació de signatura: "

	msgid "Not a valid keygrip (expecting 40 hex digits)\n"
	msgstr ""

	#, fuzzy
	msgid "No key with this keygrip\n"
	msgstr "No hi ha cap ID amb l'índex %d\n"

	#, fuzzy, c-format
	msgid "error reading the card: %s\n"
	msgstr "%s: error en llegir el registre lliure: %s\n"

	#, fuzzy, c-format
	msgid "Serial number of the card: %s\n"
	msgstr "error en la creació de la contrasenya: %s\n"

	#, fuzzy
	msgid "Available keys:\n"
	msgstr "desactiva una clau"

	#, fuzzy, c-format
	#\| msgid "rounded up to %u bits\n"
	msgid "rounded to %u bits\n"
	msgstr "arrodonida fins a %u bits\n"

	#, c-format
	msgid "%s keys may be between %u and %u bits long.\n"
	msgstr ""

	#, fuzzy, c-format
	msgid "What keysize do you want for the subkey? (%u) "
	msgstr "Quina grandària voleu? (1024) "

	#, c-format
	msgid "Requested keysize is %u bits\n"
	msgstr "La grandària sol·licitada és %u bits\n"

	#, fuzzy
	#\| msgid "Please select what kind of key you want:\n"
	msgid "Please select which elliptic curve you want:\n"
	msgstr "Seleccioneu quin tipus de clau voleu:\n"

	msgid ""
	"Please specify how long the key should be valid.\n"
	" 0 = key does not expire\n"
	" <n> = key expires in n days\n"
	" <n>w = key expires in n weeks\n"
	" <n>m = key expires in n months\n"
	" <n>y = key expires in n years\n"
	msgstr ""
	"Especifiqueu el temps de validesa de la clau.\n"
	" 0 = la clau no caduca\n"
	" <n> = la clau caduca als n dies\n"
	" <n>w = la clau caduca a les n setmanes\n"
	" <n>m = la clau caduca als n mesos\n"
	" <n>y = la clau caduca als n anys\n"

	msgid ""
	"Please specify how long the signature should be valid.\n"
	" 0 = signature does not expire\n"
	" <n> = signature expires in n days\n"
	" <n>w = signature expires in n weeks\n"
	" <n>m = signature expires in n months\n"
	" <n>y = signature expires in n years\n"
	msgstr ""
	"Especifiqueu el temps de validesa de la signatura.\n"
	" 0 = la signatura no caduca\n"
	" <n> = la signatura caduca als n dies\n"
	" <n>w = la signatura caduca a les n setmanes\n"
	" <n>m = la signatura caduca als n mesos\n"
	" <n>y = la signatura caduca als n anys\n"

	msgid "Key is valid for? (0) "
	msgstr "Indiqueu la validesa de la clau (0) "

	#, fuzzy, c-format
	msgid "Signature is valid for? (%s) "
	msgstr "Indiqueu la validesa de la signatura (0) "

	msgid "invalid value\n"
	msgstr "el valor no és vàlid\n"

	#, fuzzy
	msgid "Key does not expire at all\n"
	msgstr "%s no caduca en absolut\n"

	#, fuzzy
	msgid "Signature does not expire at all\n"
	msgstr "%s no caduca en absolut\n"

	#, fuzzy, c-format
	msgid "Key expires at %s\n"
	msgstr "%s caduca el %s\n"

	#, fuzzy, c-format
	msgid "Signature expires at %s\n"
	msgstr "Aquesta signatura caduca el %s\n"

	# Amb «it» es refereix a les dates? ivb
	# Això vaig entendre jo. jm
	msgid ""
	"Your system can't display dates beyond 2038.\n"
	"However, it will be correctly handled up to 2106.\n"
	msgstr ""
	"El vostre sistema no pot representar dates posteriors a l'any 2038.\n"
	"Tanmateix, les tractarà bé fins l'any 2106.\n"

	#, fuzzy
	msgid "Is this correct? (y/N) "
	msgstr "És correcte? (s/n)"

	msgid ""
	"\n"
	"GnuPG needs to construct a user ID to identify your key.\n"
	"\n"
	msgstr ""

	#. TRANSLATORS: This string is in general not anymore used
	#. but you should keep your existing translation. In case
	#. the new string is not translated this old string will
	#. be used.
	#, fuzzy
	msgid ""
	"\n"
	"You need a user ID to identify your key; the software constructs the user "
	"ID\n"
	"from the Real Name, Comment and Email Address in this form:\n"
	" \"Heinrich Heine (Der Dichter) <heinrichh@duesseldorf.de>\"\n"
	"\n"
	msgstr ""
	"\n"
	"Necessiteu un ID d'usuari per a identificar la vostra clau; el programa\n"
	"construeix l'id de l'usuari amb el Nom, Comentari i Adreça electrònica\n"
	"d'aquesta forma:\n"
	" \"Heinrich Heine (Der Dichter) <heinrichh@duesseldorf.de>\"\n"
	"\n"

	msgid "Real name: "
	msgstr "Nom i cognoms: "

	msgid "Invalid character in name\n"
	msgstr "Hi ha un caràcter invàlid en el camp nom\n"

	#, c-format
	msgid "The characters '%s' and '%s' may not appear in name\n"
	msgstr ""

	msgid "Name may not start with a digit\n"
	msgstr "El nom no pot començar amb un dígit\n"

	msgid "Name must be at least 5 characters long\n"
	msgstr "El nom ha de tenir, si més no, 5 caràcters\n"

	msgid "Email address: "
	msgstr "Adreça electrònica: "

	msgid "Not a valid email address\n"
	msgstr "No és una adreça vàlida\n"

	msgid "Comment: "
	msgstr "Comentari: "

	msgid "Invalid character in comment\n"
	msgstr "Hi ha un caràcter invàlid en el camp comentari\n"

	#, fuzzy, c-format
	#\| msgid "You are using the `%s' character set.\n"
	msgid "You are using the '%s' character set.\n"
	msgstr "Esteu usant el joc de caràcters `%s'.\n"

	#, c-format
	msgid ""
	"You selected this USER-ID:\n"
	" \"%s\"\n"
	"\n"
	msgstr ""
	"Heu triat l'identificador d'usuari:\n"
	" \"%s\"\n"
	"\n"

	msgid "Please don't put the email address into the real name or the comment\n"
	msgstr "No inclogueu l'adreça ni en el camp nom ni en el camp comentari\n"

	# xX? ivb
	# Hmm... sí. jm
	#. TRANSLATORS: These are the allowed answers in
	#. lower and uppercase. Below you will find the matching
	#. string which should be translated accordingly and the
	#. letter changed to match the one in the answer string.
	#.
	#. n = Change name
	#. c = Change comment
	#. e = Change email
	#. o = Okay (ready, continue)
	#. q = Quit
	#.
	msgid "NnCcEeOoQq"
	msgstr "NnCcEeOoXx"

	msgid "Change (N)ame, (C)omment, (E)mail or (Q)uit? "
	msgstr "Canvia (N)om, (C)omentari, (E)mail o (X) ix "

	msgid "Change (N)ame, (C)omment, (E)mail or (O)kay/(Q)uit? "
	msgstr "Canvia (N)om, (C)omentari, (E)mail o (O) d'acord / (X) ix"

	#, fuzzy
	#\| msgid "Change (N)ame, (C)omment, (E)mail or (Q)uit? "
	msgid "Change (N)ame, (E)mail, or (Q)uit? "
	msgstr "Canvia (N)om, (C)omentari, (E)mail o (X) ix "

	#, fuzzy
	#\| msgid "Change (N)ame, (C)omment, (E)mail or (O)kay/(Q)uit? "
	msgid "Change (N)ame, (E)mail, or (O)kay/(Q)uit? "
	msgstr "Canvia (N)om, (C)omentari, (E)mail o (O) d'acord / (X) ix"

	msgid "Please correct the error first\n"
	msgstr "Corregiu l'error primer\n"

	msgid ""
	"We need to generate a lot of random bytes. It is a good idea to perform\n"
	"some other action (type on the keyboard, move the mouse, utilize the\n"
	"disks) during the prime generation; this gives the random number\n"
	"generator a better chance to gain enough entropy.\n"
	msgstr ""
	"Cal generar molts bits aleatòriament. És bona idea fer alguna altra cosa\n"
	"(teclejar, moure el ratolí, usar els discos) durant la generació de\n"
	"nombres primers; açò dóna oportunitat al generador de nombres aleatoris\n"
	"d'aconseguir prou entropia.\n"

	#, c-format
	msgid "Key generation failed: %s\n"
	msgstr "La generació de claus ha fallat: %s\n"

	#, c-format
	msgid ""
	"About to create a key for:\n"
	" \"%s\"\n"
	"\n"
	msgstr ""

	msgid "Continue? (Y/n) "
	msgstr ""

	#, fuzzy, c-format
	msgid "A key for \"%s\" already exists\n"
	msgstr "«%s» ja està comprimida\n"

	#, fuzzy
	#\| msgid "Create anyway? "
	msgid "Create anyway? (y/N) "
	msgstr "Voleu crear la clau de tota manera? "

	#, fuzzy, c-format
	#\| msgid "Create anyway? "
	msgid "creating anyway\n"
	msgstr "Voleu crear la clau de tota manera? "

	#, c-format
	msgid "Note: Use \"%s %s\" for a full featured key generation dialog.\n"
	msgstr ""

	#, c-format
	msgid "Key generation canceled.\n"
	msgstr "La generació de claus ha estat cancel·lada.\n"

	#, fuzzy, c-format
	msgid "can't create backup file '%s': %s\n"
	msgstr "no s'ha pogut crear «%s»: %s\n"

	#, c-format
	msgid "Note: backup of card key saved to '%s'\n"
	msgstr ""

	#, fuzzy, c-format
	#\| msgid "writing public key to `%s'\n"
	msgid "writing public key to '%s'\n"
	msgstr "s'està escrivint la clau pública a «%s»\n"

	# Potser no hi haja cap anell! ivb
	#, c-format
	msgid "no writable public keyring found: %s\n"
	msgstr "no s'ha trobat cap anell públic escrivible: %s\n"

	#, fuzzy, c-format
	#\| msgid "error writing public keyring `%s': %s\n"
	msgid "error writing public keyring '%s': %s\n"
	msgstr "s'ha produït un error mentre s'escrivia l'anell públic «%s»: %s\n"

	msgid "public and secret key created and signed.\n"
	msgstr "s'han creat i signat les claus pública i secreta.\n"

	#, fuzzy
	msgid ""
	"Note that this key cannot be used for encryption. You may want to use\n"
	"the command \"--edit-key\" to generate a subkey for this purpose.\n"
	msgstr ""
	"Noteu que aquesta clau no serveix per a xifrar. Potser vulgueu usar l'ordre\n"
	"\"--edit-key\" per a generar una clau secundària per a tal propòsit.\n"

	# Werner FIXME: Use ngettext. jm
	#, c-format
	msgid ""
	"key has been created %lu second in future (time warp or clock problem)\n"
	msgstr ""
	"la clau s'ha creat %lu segon en el futur (salt en el temps o problemes\n"
	"amb el rellotge)\n"

	# Werner FIXME: use ngettext. jm
	#, c-format
	msgid ""
	"key has been created %lu seconds in future (time warp or clock problem)\n"
	msgstr ""
	"la clau s'ha creat %lu segons en el futur (salt en el temps o problemes\n"
	"amb el rellotge)\n"

	#, fuzzy, c-format
	#\| msgid "NOTE: creating subkeys for v3 keys is not OpenPGP compliant\n"
	msgid "Note: creating subkeys for v3 keys is not OpenPGP compliant\n"
	msgstr "NOTA: crear subclaus per a claus v3 no és conforme amb OpenPGP\n"

	#, c-format
	msgid "Secret parts of primary key are not available.\n"
	msgstr "Les parts secretes de la clau primària no estan disponibles.\n"

	#, fuzzy, c-format
	msgid "Secret parts of primary key are stored on-card.\n"
	msgstr "Les parts secretes de la clau primària no estan disponibles.\n"

	#, fuzzy
	msgid "Really create? (y/N) "
	msgstr "Crear realment? "

	msgid "never "
	msgstr "mai "

	msgid "AEAD: "
	msgstr ""

	msgid "Digest: "
	msgstr "Resum: "

	msgid "Features: "
	msgstr "Funcionalitats: "

	msgid "Keyserver no-modify"
	msgstr ""

	msgid "Critical signature policy: "
	msgstr "Política de signatura crítica: "

	msgid "Signature policy: "
	msgstr "Política de signatura: "

	msgid "Critical preferred keyserver: "
	msgstr ""

	msgid "Critical signature notation: "
	msgstr "Notació de signatura crítica: "

	msgid "Signature notation: "
	msgstr "Notació de signatura: "

	#, fuzzy, c-format
	#\| msgid "%d bad signatures\n"
	msgid "%d good signature\n"
	msgid_plural "%d good signatures\n"
	msgstr[0] "%d signatures errònies\n"
	msgstr[1] "%d signatures errònies\n"

	#, fuzzy, c-format
	#\| msgid "1 signature not checked due to an error\n"
	msgid "%d signature not checked due to an error\n"
	msgid_plural "%d signatures not checked due to errors\n"
	msgstr[0] "1 signatura no comprovada a causa d'un error\n"
	msgstr[1] "1 signatura no comprovada a causa d'un error\n"

	#, c-format
	msgid "Warning: %lu key skipped due to its large size\n"
	msgid_plural "Warning: %lu keys skipped due to their large sizes\n"
	msgstr[0] ""
	msgstr[1] ""

	msgid "Keyring"
	msgstr "Anell"

	msgid "Primary key fingerprint:"
	msgstr "Empremtes digital de la clau primària:"

	msgid " Subkey fingerprint:"
	msgstr " Empremta digital de la subclau:"

	#. TRANSLATORS: this should fit into 24 bytes so that the
	#. * fingerprint data is properly aligned with the user ID
	msgid " Primary key fingerprint:"
	msgstr " Empremta digital de la clau primària:"

	msgid " Subkey fingerprint:"
	msgstr " Empremta digital de la subclau:"

	#, fuzzy
	msgid " Key fingerprint ="
	msgstr " Empremta digital ="

	msgid " Card serial no. ="
	msgstr ""

	#, fuzzy, c-format
	msgid "caching keyring '%s'\n"
	msgstr "s'està comprovant l'anell «%s»\n"

	#, fuzzy, c-format
	msgid "%lu keys cached so far (%lu signature)\n"
	msgid_plural "%lu keys cached so far (%lu signatures)\n"
	msgstr[0] "s'han comprovat %lu claus (%lu signatures)\n"
	msgstr[1] "s'han comprovat %lu claus (%lu signatures)\n"

	#, fuzzy, c-format
	#\| msgid "\t%lu keys updated\n"
	msgid "%lu key cached"
	msgid_plural "%lu keys cached"
	msgstr[0] "\t%lu clau actualitzades\n"
	msgstr[1] "\t%lu clau actualitzades\n"

	#, fuzzy, c-format
	#\| msgid "1 bad signature\n"
	msgid " (%lu signature)\n"
	msgid_plural " (%lu signatures)\n"
	msgstr[0] "1 signatura errònia\n"
	msgstr[1] "1 signatura errònia\n"

	# Fitxer indi fins final. Hau! ivb
	# Grrr. Com em tracten els esclaus ja... jm
	#, c-format
	msgid "%s: keyring created\n"
	msgstr "%s: s'ha creat l'anell\n"

	msgid "override proxy options set for dirmngr"
	msgstr ""

	msgid "include revoked keys in search results"
	msgstr ""

	msgid "include subkeys when searching by key ID"
	msgstr ""

	msgid "override timeout options set for dirmngr"
	msgstr ""

	msgid "automatically retrieve keys when verifying signatures"
	msgstr ""

	#, fuzzy
	msgid "honor the preferred keyserver URL set on the key"
	msgstr "la URL de política de signatura donada no és vàlida\n"

	msgid "honor the PKA record set on a key when retrieving keys"
	msgstr ""

	#, fuzzy
	msgid "disabled"
	msgstr "disable"

	msgid "Enter number(s), N)ext, or Q)uit > "
	msgstr ""

	#, c-format
	msgid "invalid keyserver protocol (us %d!=handler %d)\n"
	msgstr ""

	#, fuzzy, c-format
	msgid "\"%s\" not a key ID: skipping\n"
	msgstr "%s: no és un ID vàlid\n"

	#, fuzzy, c-format
	msgid "refreshing %d key from %s\n"
	msgid_plural "refreshing %d keys from %s\n"
	msgstr[0] "s'està sol·licitant la clau %08lX de %s\n"
	msgstr[1] "s'està sol·licitant la clau %08lX de %s\n"

	#, fuzzy, c-format
	msgid "WARNING: unable to refresh key %s via %s: %s\n"
	msgstr "AVÍS: no s'ha pogut eliminar el fitxer temporal (%s) «%s»: %s\n"

	#, fuzzy, c-format
	msgid "key \"%s\" not found on keyserver\n"
	msgstr "no s'ha trobat la clau «%s»: %s\n"

	#, fuzzy, c-format
	msgid "key not found on keyserver\n"
	msgstr "no s'ha trobat la clau «%s»: %s\n"

	#, fuzzy, c-format
	msgid "requesting key %s from %s\n"
	msgstr "s'està sol·licitant la clau %08lX de %s\n"

	# «del servidor», «en el servidor»? ivb
	#, fuzzy, c-format
	msgid "no keyserver known\n"
	msgstr "error de servidor de claus"

	#, fuzzy, c-format
	msgid "skipped \"%s\": %s\n"
	msgstr "es descarta «%s»: %s\n"

	#, fuzzy, c-format
	msgid "sending key %s to %s\n"
	msgstr "s'està sol·licitant la clau %08lX de %s\n"

	#, fuzzy, c-format
	msgid "requesting key from '%s'\n"
	msgstr "s'està sol·licitant la clau %08lX de %s\n"

	#, fuzzy, c-format
	msgid "WARNING: unable to fetch URI %s: %s\n"
	msgstr "AVÍS: no s'ha pogut eliminar el fitxer temporal (%s) «%s»: %s\n"

	#, c-format
	msgid "weird size for an encrypted session key (%d)\n"
	msgstr "mida extranya per a una clau de sessió xifrada (%d)\n"

	#, c-format
	msgid "%s encrypted session key\n"
	msgstr "clau de sessió xifrada amb %s\n"

	#, fuzzy, c-format
	msgid "passphrase generated with unknown digest algorithm %d\n"
	msgstr "xifrat amb l'algoritme %d (desconegut)\n"

	#, fuzzy, c-format
	msgid "public key is %s\n"
	msgstr "la clau pública és %08lX\n"

	#, c-format
	msgid "public key encrypted data: good DEK\n"
	msgstr "dades xifrades amb clau pública: bona clau de xifratge (DEK)\n"

	#, fuzzy, c-format
	msgid "encrypted with %u-bit %s key, ID %s, created %s\n"
	msgstr "xifrat amb una clau %2$s de %1$u bits, ID %3$08lX, creada en %4$s\n"

	#, c-format
	msgid " \"%s\"\n"
	msgstr ""

	#, fuzzy, c-format
	msgid "encrypted with %s key, ID %s\n"
	msgstr "xifrat amb una clau %s, ID %08lX\n"

	#, c-format
	msgid "public key decryption failed: %s\n"
	msgstr "ha fallat el desxifratge amb la clau pública: %s\n"

	#, c-format
	msgid "WARNING: multiple plaintexts seen\n"
	msgstr ""

	#, c-format
	msgid "encrypted with %lu passphrases\n"
	msgstr "xifrat amb %lu contrasenyes\n"

	# FIXME WK: Use ngettext
	#, c-format
	msgid "encrypted with 1 passphrase\n"
	msgstr "xifrat amb 1 contrasenya\n"

	# I no serà «dades xifrades amb %s»? ivb
	# Sembla que sí, ho marque per a mirar-ho més endavant. jm
	#, c-format
	msgid "assuming %s encrypted data\n"
	msgstr "s'assumeixen dades xifrades amb %s\n"

	# L'optimístic és aquell que té una Fe Cega en que Tot Anirà Bé! ivb
	#, c-format
	msgid "IDEA cipher unavailable, optimistically attempting to use %s instead\n"
	msgstr ""
	"El xifratge IDEA no està disponible,

No OneTemporaryActions

View Options

No OneTemporary
Actions