gpg: Minor cleanup for key listing related code.
[gnupg.git] / g10 / getkey.c
1 /* getkey.c -  Get a key from the database
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
3  *               2007, 2008, 2010  Free Software Foundation, Inc.
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 3 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, see <http://www.gnu.org/licenses/>.
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <assert.h>
26 #include <ctype.h>
27
28 #include "gpg.h"
29 #include "util.h"
30 #include "packet.h"
31 #include "iobuf.h"
32 #include "keydb.h"
33 #include "options.h"
34 #include "main.h"
35 #include "trustdb.h"
36 #include "i18n.h"
37 #include "keyserver-internal.h"
38 #include "call-agent.h"
39
40 #define MAX_PK_CACHE_ENTRIES   PK_UID_CACHE_SIZE
41 #define MAX_UID_CACHE_ENTRIES  PK_UID_CACHE_SIZE
42
43 #if MAX_PK_CACHE_ENTRIES < 2
44 #error We need the cache for key creation
45 #endif
46
47 struct getkey_ctx_s
48 {
49   int exact;
50   int want_secret;       /* The caller requested only secret keys.  */
51   KBNODE keyblock;
52   KBPOS kbpos;
53   KBNODE found_key;      /* Pointer into some keyblock. */
54   strlist_t extra_list;  /* Will be freed when releasing the context.  */
55   int last_rc;
56   int req_usage;
57   int req_algo;
58   KEYDB_HANDLE kr_handle;
59   int not_allocated;
60   int nitems;
61   KEYDB_SEARCH_DESC items[1];
62 };
63
64 #if 0
65 static struct
66 {
67   int any;
68   int okay_count;
69   int nokey_count;
70   int error_count;
71 } lkup_stats[21];
72 #endif
73
74 typedef struct keyid_list
75 {
76   struct keyid_list *next;
77   char fpr[MAX_FINGERPRINT_LEN];
78   u32 keyid[2];
79 } *keyid_list_t;
80
81
82 #if MAX_PK_CACHE_ENTRIES
83 typedef struct pk_cache_entry
84 {
85   struct pk_cache_entry *next;
86   u32 keyid[2];
87   PKT_public_key *pk;
88 } *pk_cache_entry_t;
89 static pk_cache_entry_t pk_cache;
90 static int pk_cache_entries;    /* Number of entries in pk cache.  */
91 static int pk_cache_disabled;
92 #endif
93
94 #if MAX_UID_CACHE_ENTRIES < 5
95 #error we really need the userid cache
96 #endif
97 typedef struct user_id_db
98 {
99   struct user_id_db *next;
100   keyid_list_t keyids;
101   int len;
102   char name[1];
103 } *user_id_db_t;
104 static user_id_db_t user_id_db;
105 static int uid_cache_entries;   /* Number of entries in uid cache. */
106
107 static void merge_selfsigs (kbnode_t keyblock);
108 static int lookup (getkey_ctx_t ctx, kbnode_t *ret_keyblock, int want_secret);
109
110 #if 0
111 static void
112 print_stats ()
113 {
114   int i;
115   for (i = 0; i < DIM (lkup_stats); i++)
116     {
117       if (lkup_stats[i].any)
118         fprintf (stderr,
119                  "lookup stats: mode=%-2d  ok=%-6d  nokey=%-6d  err=%-6d\n",
120                  i,
121                  lkup_stats[i].okay_count,
122                  lkup_stats[i].nokey_count, lkup_stats[i].error_count);
123     }
124 }
125 #endif
126
127
128 void
129 cache_public_key (PKT_public_key * pk)
130 {
131 #if MAX_PK_CACHE_ENTRIES
132   pk_cache_entry_t ce, ce2;
133   u32 keyid[2];
134
135   if (pk_cache_disabled)
136     return;
137
138   if (pk->flags.dont_cache)
139     return;
140
141   if (is_ELGAMAL (pk->pubkey_algo)
142       || pk->pubkey_algo == PUBKEY_ALGO_DSA
143       || pk->pubkey_algo == PUBKEY_ALGO_ECDSA
144       || pk->pubkey_algo == PUBKEY_ALGO_EDDSA
145       || pk->pubkey_algo == PUBKEY_ALGO_ECDH
146       || is_RSA (pk->pubkey_algo))
147     {
148       keyid_from_pk (pk, keyid);
149     }
150   else
151     return; /* Don't know how to get the keyid.  */
152
153   for (ce = pk_cache; ce; ce = ce->next)
154     if (ce->keyid[0] == keyid[0] && ce->keyid[1] == keyid[1])
155       {
156         if (DBG_CACHE)
157           log_debug ("cache_public_key: already in cache\n");
158         return;
159       }
160
161   if (pk_cache_entries >= MAX_PK_CACHE_ENTRIES)
162     {
163       int n;
164
165       /* Remove the last 50% of the entries.  */
166       for (ce = pk_cache, n = 0; ce && n < pk_cache_entries/2; n++)
167         ce = ce->next;
168       if (ce != pk_cache && ce->next)
169         {
170           ce2 = ce->next;
171           ce->next = NULL;
172           ce = ce2;
173           for (; ce; ce = ce2)
174             {
175               ce2 = ce->next;
176               free_public_key (ce->pk);
177               xfree (ce);
178               pk_cache_entries--;
179             }
180         }
181       assert (pk_cache_entries < MAX_PK_CACHE_ENTRIES);
182     }
183   pk_cache_entries++;
184   ce = xmalloc (sizeof *ce);
185   ce->next = pk_cache;
186   pk_cache = ce;
187   ce->pk = copy_public_key (NULL, pk);
188   ce->keyid[0] = keyid[0];
189   ce->keyid[1] = keyid[1];
190 #endif
191 }
192
193
194 /* Return a const utf-8 string with the text "[User ID not found]".
195    This function is required so that we don't need to switch gettext's
196    encoding temporary.  */
197 static const char *
198 user_id_not_found_utf8 (void)
199 {
200   static char *text;
201
202   if (!text)
203     text = native_to_utf8 (_("[User ID not found]"));
204   return text;
205 }
206
207
208
209 /* Return the user ID from the given keyblock.
210  * We use the primary uid flag which has been set by the merge_selfsigs
211  * function.  The returned value is only valid as long as then given
212  * keyblock is not changed.  */
213 static const char *
214 get_primary_uid (KBNODE keyblock, size_t * uidlen)
215 {
216   KBNODE k;
217   const char *s;
218
219   for (k = keyblock; k; k = k->next)
220     {
221       if (k->pkt->pkttype == PKT_USER_ID
222           && !k->pkt->pkt.user_id->attrib_data
223           && k->pkt->pkt.user_id->is_primary)
224         {
225           *uidlen = k->pkt->pkt.user_id->len;
226           return k->pkt->pkt.user_id->name;
227         }
228     }
229   s = user_id_not_found_utf8 ();
230   *uidlen = strlen (s);
231   return s;
232 }
233
234
235 static void
236 release_keyid_list (keyid_list_t k)
237 {
238   while (k)
239     {
240       keyid_list_t k2 = k->next;
241       xfree (k);
242       k = k2;
243     }
244 }
245
246 /****************
247  * Store the association of keyid and userid
248  * Feed only public keys to this function.
249  */
250 static void
251 cache_user_id (KBNODE keyblock)
252 {
253   user_id_db_t r;
254   const char *uid;
255   size_t uidlen;
256   keyid_list_t keyids = NULL;
257   KBNODE k;
258
259   for (k = keyblock; k; k = k->next)
260     {
261       if (k->pkt->pkttype == PKT_PUBLIC_KEY
262           || k->pkt->pkttype == PKT_PUBLIC_SUBKEY)
263         {
264           keyid_list_t a = xmalloc_clear (sizeof *a);
265           /* Hmmm: For a long list of keyids it might be an advantage
266            * to append the keys.  */
267           fingerprint_from_pk (k->pkt->pkt.public_key, a->fpr, NULL);
268           keyid_from_pk (k->pkt->pkt.public_key, a->keyid);
269           /* First check for duplicates.  */
270           for (r = user_id_db; r; r = r->next)
271             {
272               keyid_list_t b = r->keyids;
273               for (b = r->keyids; b; b = b->next)
274                 {
275                   if (!memcmp (b->fpr, a->fpr, MAX_FINGERPRINT_LEN))
276                     {
277                       if (DBG_CACHE)
278                         log_debug ("cache_user_id: already in cache\n");
279                       release_keyid_list (keyids);
280                       xfree (a);
281                       return;
282                     }
283                 }
284             }
285           /* Now put it into the cache.  */
286           a->next = keyids;
287           keyids = a;
288         }
289     }
290   if (!keyids)
291     BUG (); /* No key no fun.  */
292
293
294   uid = get_primary_uid (keyblock, &uidlen);
295
296   if (uid_cache_entries >= MAX_UID_CACHE_ENTRIES)
297     {
298       /* fixme: use another algorithm to free some cache slots */
299       r = user_id_db;
300       user_id_db = r->next;
301       release_keyid_list (r->keyids);
302       xfree (r);
303       uid_cache_entries--;
304     }
305   r = xmalloc (sizeof *r + uidlen - 1);
306   r->keyids = keyids;
307   r->len = uidlen;
308   memcpy (r->name, uid, r->len);
309   r->next = user_id_db;
310   user_id_db = r;
311   uid_cache_entries++;
312 }
313
314
315 void
316 getkey_disable_caches ()
317 {
318 #if MAX_PK_CACHE_ENTRIES
319   {
320     pk_cache_entry_t ce, ce2;
321
322     for (ce = pk_cache; ce; ce = ce2)
323       {
324         ce2 = ce->next;
325         free_public_key (ce->pk);
326         xfree (ce);
327       }
328     pk_cache_disabled = 1;
329     pk_cache_entries = 0;
330     pk_cache = NULL;
331   }
332 #endif
333   /* fixme: disable user id cache ? */
334 }
335
336
337 static void
338 pk_from_block (GETKEY_CTX ctx, PKT_public_key * pk, KBNODE keyblock)
339 {
340   KBNODE a = ctx->found_key ? ctx->found_key : keyblock;
341
342   assert (a->pkt->pkttype == PKT_PUBLIC_KEY
343           || a->pkt->pkttype == PKT_PUBLIC_SUBKEY);
344
345   copy_public_key (pk, a->pkt->pkt.public_key);
346 }
347
348 /* Get a public key and store it into the allocated pk can be called
349  * with PK set to NULL to just read it into some internal
350  * structures.  */
351 int
352 get_pubkey (PKT_public_key * pk, u32 * keyid)
353 {
354   int internal = 0;
355   int rc = 0;
356
357 #if MAX_PK_CACHE_ENTRIES
358   if (pk)
359     {
360       /* Try to get it from the cache.  We don't do this when pk is
361          NULL as it does not guarantee that the user IDs are
362          cached. */
363       pk_cache_entry_t ce;
364       for (ce = pk_cache; ce; ce = ce->next)
365         {
366           if (ce->keyid[0] == keyid[0] && ce->keyid[1] == keyid[1])
367             {
368               copy_public_key (pk, ce->pk);
369               return 0;
370             }
371         }
372     }
373 #endif
374   /* More init stuff.  */
375   if (!pk)
376     {
377       pk = xmalloc_clear (sizeof *pk);
378       internal++;
379     }
380
381
382   /* Do a lookup.  */
383   {
384     struct getkey_ctx_s ctx;
385     KBNODE kb = NULL;
386     memset (&ctx, 0, sizeof ctx);
387     ctx.exact = 1; /* Use the key ID exactly as given.  */
388     ctx.not_allocated = 1;
389     ctx.kr_handle = keydb_new ();
390     ctx.nitems = 1;
391     ctx.items[0].mode = KEYDB_SEARCH_MODE_LONG_KID;
392     ctx.items[0].u.kid[0] = keyid[0];
393     ctx.items[0].u.kid[1] = keyid[1];
394     ctx.req_algo = pk->req_algo;
395     ctx.req_usage = pk->req_usage;
396     rc = lookup (&ctx, &kb, 0);
397     if (!rc)
398       {
399         pk_from_block (&ctx, pk, kb);
400       }
401     get_pubkey_end (&ctx);
402     release_kbnode (kb);
403   }
404   if (!rc)
405     goto leave;
406
407   rc = G10ERR_NO_PUBKEY;
408
409 leave:
410   if (!rc)
411     cache_public_key (pk);
412   if (internal)
413     free_public_key (pk);
414   return rc;
415 }
416
417
418 /* Get a public key and store it into the allocated pk.  This function
419    differs from get_pubkey() in that it does not do a check of the key
420    to avoid recursion.  It should be used only in very certain cases.
421    It will only retrieve primary keys.  */
422 int
423 get_pubkey_fast (PKT_public_key * pk, u32 * keyid)
424 {
425   int rc = 0;
426   KEYDB_HANDLE hd;
427   KBNODE keyblock;
428   u32 pkid[2];
429
430   assert (pk);
431 #if MAX_PK_CACHE_ENTRIES
432   {
433     /* Try to get it from the cache */
434     pk_cache_entry_t ce;
435
436     for (ce = pk_cache; ce; ce = ce->next)
437       {
438         if (ce->keyid[0] == keyid[0] && ce->keyid[1] == keyid[1])
439           {
440             if (pk)
441               copy_public_key (pk, ce->pk);
442             return 0;
443           }
444       }
445   }
446 #endif
447
448   hd = keydb_new ();
449   rc = keydb_search_kid (hd, keyid);
450   if (gpg_err_code (rc) == GPG_ERR_NOT_FOUND)
451     {
452       keydb_release (hd);
453       return G10ERR_NO_PUBKEY;
454     }
455   rc = keydb_get_keyblock (hd, &keyblock);
456   keydb_release (hd);
457   if (rc)
458     {
459       log_error ("keydb_get_keyblock failed: %s\n", g10_errstr (rc));
460       return G10ERR_NO_PUBKEY;
461     }
462
463   assert (keyblock && keyblock->pkt
464           && (keyblock->pkt->pkttype == PKT_PUBLIC_KEY
465               || keyblock->pkt->pkttype == PKT_PUBLIC_SUBKEY));
466
467   keyid_from_pk (keyblock->pkt->pkt.public_key, pkid);
468   if (keyid[0] == pkid[0] && keyid[1] == pkid[1])
469     copy_public_key (pk, keyblock->pkt->pkt.public_key);
470   else
471     rc = G10ERR_NO_PUBKEY;
472
473   release_kbnode (keyblock);
474
475   /* Not caching key here since it won't have all of the fields
476      properly set. */
477
478   return rc;
479 }
480
481
482 KBNODE
483 get_pubkeyblock (u32 * keyid)
484 {
485   struct getkey_ctx_s ctx;
486   int rc = 0;
487   KBNODE keyblock = NULL;
488
489   memset (&ctx, 0, sizeof ctx);
490   /* No need to set exact here because we want the entire block.  */
491   ctx.not_allocated = 1;
492   ctx.kr_handle = keydb_new ();
493   ctx.nitems = 1;
494   ctx.items[0].mode = KEYDB_SEARCH_MODE_LONG_KID;
495   ctx.items[0].u.kid[0] = keyid[0];
496   ctx.items[0].u.kid[1] = keyid[1];
497   rc = lookup (&ctx, &keyblock, 0);
498   get_pubkey_end (&ctx);
499
500   return rc ? NULL : keyblock;
501 }
502
503
504
505
506 /*
507  * Get a public key and store it into PK.  This functions check that a
508  * corresponding secret key is available.  With no secret key it does
509  * not succeeed.
510  */
511 gpg_error_t
512 get_seckey (PKT_public_key *pk, u32 *keyid)
513 {
514   gpg_error_t err;
515   struct getkey_ctx_s ctx;
516   kbnode_t keyblock = NULL;
517
518   memset (&ctx, 0, sizeof ctx);
519   ctx.exact = 1; /* Use the key ID exactly as given.  */
520   ctx.not_allocated = 1;
521   ctx.kr_handle = keydb_new ();
522   ctx.nitems = 1;
523   ctx.items[0].mode = KEYDB_SEARCH_MODE_LONG_KID;
524   ctx.items[0].u.kid[0] = keyid[0];
525   ctx.items[0].u.kid[1] = keyid[1];
526   ctx.req_algo = pk->req_algo;
527   ctx.req_usage = pk->req_usage;
528   err = lookup (&ctx, &keyblock, 1);
529   if (!err)
530     {
531       pk_from_block (&ctx, pk, keyblock);
532     }
533   get_pubkey_end (&ctx);
534   release_kbnode (keyblock);
535
536   if (!err)
537     err = agent_probe_secret_key (/*ctrl*/NULL, pk);
538
539   return err;
540 }
541
542
543 static int
544 skip_unusable (void *dummy, u32 * keyid, PKT_user_id * uid)
545 {
546   int unusable = 0;
547   KBNODE keyblock;
548
549   (void) dummy;
550
551   keyblock = get_pubkeyblock (keyid);
552   if (!keyblock)
553     {
554       log_error ("error checking usability status of %s\n", keystr (keyid));
555       goto leave;
556     }
557
558   /* Is the user ID in question revoked/expired? */
559   if (uid)
560     {
561       KBNODE node;
562
563       for (node = keyblock; node; node = node->next)
564         {
565           if (node->pkt->pkttype == PKT_USER_ID)
566             {
567               if (cmp_user_ids (uid, node->pkt->pkt.user_id) == 0
568                   && (node->pkt->pkt.user_id->is_revoked
569                       || node->pkt->pkt.user_id->is_expired))
570                 {
571                   unusable = 1;
572                   break;
573                 }
574             }
575         }
576     }
577
578   if (!unusable)
579     unusable = pk_is_disabled (keyblock->pkt->pkt.public_key);
580
581 leave:
582   release_kbnode (keyblock);
583   return unusable;
584 }
585
586
587 /* Try to get the pubkey by the userid.  This function looks for the
588  * first pubkey certificate which has the given name in a user_id.  If
589  * PK has the pubkey algo set, the function will only return a pubkey
590  * with that algo.  If NAMELIST is NULL, the first key is returned.
591  * The caller should provide storage for the PK or pass NULL if it is
592  * not needed.  If RET_KB is not NULL the function stores the entire
593  * keyblock at that address.  */
594 static int
595 key_byname (GETKEY_CTX *retctx, strlist_t namelist,
596             PKT_public_key *pk,
597             int want_secret, int include_unusable,
598             KBNODE * ret_kb, KEYDB_HANDLE * ret_kdbhd)
599 {
600   int rc = 0;
601   int n;
602   strlist_t r;
603   GETKEY_CTX ctx;
604   KBNODE help_kb = NULL;
605
606   if (retctx)
607     {
608       /* Reset the returned context in case of error.  */
609       assert (!ret_kdbhd); /* Not allowed because the handle is stored
610                               in the context.  */
611       *retctx = NULL;
612     }
613   if (ret_kdbhd)
614     *ret_kdbhd = NULL;
615
616   if (!namelist)
617     {
618       ctx = xmalloc_clear (sizeof *ctx);
619       ctx->nitems = 1;
620       ctx->items[0].mode = KEYDB_SEARCH_MODE_FIRST;
621       if (!include_unusable)
622         ctx->items[0].skipfnc = skip_unusable;
623     }
624   else
625     {
626       /* Build the search context.  */
627       for (n = 0, r = namelist; r; r = r->next)
628         n++;
629
630       ctx = xmalloc_clear (sizeof *ctx + (n - 1) * sizeof ctx->items);
631       ctx->nitems = n;
632
633       for (n = 0, r = namelist; r; r = r->next, n++)
634         {
635           gpg_error_t err;
636
637           err = classify_user_id (r->d, &ctx->items[n], 1);
638
639           if (ctx->items[n].exact)
640             ctx->exact = 1;
641           if (err)
642             {
643               xfree (ctx);
644               return gpg_err_code (err); /* FIXME: remove gpg_err_code.  */
645             }
646           if (!include_unusable
647               && ctx->items[n].mode != KEYDB_SEARCH_MODE_SHORT_KID
648               && ctx->items[n].mode != KEYDB_SEARCH_MODE_LONG_KID
649               && ctx->items[n].mode != KEYDB_SEARCH_MODE_FPR16
650               && ctx->items[n].mode != KEYDB_SEARCH_MODE_FPR20
651               && ctx->items[n].mode != KEYDB_SEARCH_MODE_FPR)
652             ctx->items[n].skipfnc = skip_unusable;
653         }
654     }
655
656   ctx->want_secret = want_secret;
657   ctx->kr_handle = keydb_new ();
658   if (!ret_kb)
659     ret_kb = &help_kb;
660
661   if (pk)
662     {
663       ctx->req_algo = pk->req_algo;
664       ctx->req_usage = pk->req_usage;
665     }
666
667   rc = lookup (ctx, ret_kb, want_secret);
668   if (!rc && pk)
669     {
670       pk_from_block (ctx, pk, *ret_kb);
671     }
672
673   release_kbnode (help_kb);
674
675   if (retctx) /* Caller wants the context.  */
676     *retctx = ctx;
677   else
678     {
679       if (ret_kdbhd)
680         {
681           *ret_kdbhd = ctx->kr_handle;
682           ctx->kr_handle = NULL;
683         }
684       get_pubkey_end (ctx);
685     }
686
687   return rc;
688 }
689
690
691
692 /* Find a public key from NAME and return the keyblock or the key.  If
693    ret_kdb is not NULL, the KEYDB handle used to locate this keyblock
694    is returned and the caller is responsible for closing it.  If a key
695    was not found (or if local search has been disabled) and NAME is a
696    valid RFC822 mailbox and --auto-key-locate has been enabled, we try
697    to import the key via the online mechanisms defined by
698    --auto-key-locate.  */
699 int
700 get_pubkey_byname (ctrl_t ctrl, GETKEY_CTX * retctx, PKT_public_key * pk,
701                    const char *name, KBNODE * ret_keyblock,
702                    KEYDB_HANDLE * ret_kdbhd, int include_unusable, int no_akl)
703 {
704   int rc;
705   strlist_t namelist = NULL;
706   struct akl *akl;
707   int is_mbox;
708   int nodefault = 0;
709   int anylocalfirst = 0;
710
711   if (retctx)
712     *retctx = NULL;
713
714   is_mbox = is_valid_mailbox (name);
715
716   /* Check whether the default local search has been disabled.
717      This is the case if either the "nodefault" or the "local" keyword
718      are in the list of auto key locate mechanisms.
719
720      ANYLOCALFIRST is set if the search order has the local method
721      before any other or if "local" is used first by default.  This
722      makes sure that if a RETCTX is used it gets only set if a local
723      search has precedence over the other search methods and only then
724      a followup call to get_pubkey_next shall succeed.  */
725   if (!no_akl)
726     {
727       for (akl = opt.auto_key_locate; akl; akl = akl->next)
728         if (akl->type == AKL_NODEFAULT || akl->type == AKL_LOCAL)
729           {
730             nodefault = 1;
731             break;
732           }
733       for (akl = opt.auto_key_locate; akl; akl = akl->next)
734         if (akl->type != AKL_NODEFAULT)
735           {
736             if (akl->type == AKL_LOCAL)
737               anylocalfirst = 1;
738             break;
739           }
740     }
741
742   if (!nodefault)
743     anylocalfirst = 1;
744
745   if (nodefault && is_mbox)
746     {
747       /* Nodefault but a mailbox - let the AKL locate the key.  */
748       rc = G10ERR_NO_PUBKEY;
749     }
750   else
751     {
752       add_to_strlist (&namelist, name);
753       rc = key_byname (retctx, namelist, pk, 0,
754                        include_unusable, ret_keyblock, ret_kdbhd);
755     }
756
757   /* If the requested name resembles a valid mailbox and automatic
758      retrieval has been enabled, we try to import the key. */
759   if (gpg_err_code (rc) == G10ERR_NO_PUBKEY && !no_akl && is_mbox)
760     {
761       for (akl = opt.auto_key_locate; akl; akl = akl->next)
762         {
763           unsigned char *fpr = NULL;
764           size_t fpr_len;
765           int did_key_byname = 0;
766           int no_fingerprint = 0;
767           const char *mechanism = "?";
768
769           switch (akl->type)
770             {
771             case AKL_NODEFAULT:
772               /* This is a dummy mechanism.  */
773               mechanism = "None";
774               rc = G10ERR_NO_PUBKEY;
775               break;
776
777             case AKL_LOCAL:
778               mechanism = "Local";
779               did_key_byname = 1;
780               if (retctx)
781                 {
782                   get_pubkey_end (*retctx);
783                   *retctx = NULL;
784                 }
785               add_to_strlist (&namelist, name);
786               rc = key_byname (anylocalfirst ? retctx : NULL,
787                                namelist, pk, 0,
788                                include_unusable, ret_keyblock, ret_kdbhd);
789               break;
790
791             case AKL_CERT:
792               mechanism = "DNS CERT";
793               glo_ctrl.in_auto_key_retrieve++;
794               rc = keyserver_import_cert (ctrl, name, &fpr, &fpr_len);
795               glo_ctrl.in_auto_key_retrieve--;
796               break;
797
798             case AKL_PKA:
799               mechanism = "PKA";
800               glo_ctrl.in_auto_key_retrieve++;
801               rc = keyserver_import_pka (ctrl, name, &fpr, &fpr_len);
802               glo_ctrl.in_auto_key_retrieve--;
803               break;
804
805             case AKL_LDAP:
806               mechanism = "LDAP";
807               glo_ctrl.in_auto_key_retrieve++;
808               rc = keyserver_import_ldap (ctrl, name, &fpr, &fpr_len);
809               glo_ctrl.in_auto_key_retrieve--;
810               break;
811
812             case AKL_KEYSERVER:
813               /* Strictly speaking, we don't need to only use a valid
814                  mailbox for the getname search, but it helps cut down
815                  on the problem of searching for something like "john"
816                  and getting a whole lot of keys back. */
817               if (opt.keyserver)
818                 {
819                   mechanism = opt.keyserver->uri;
820                   glo_ctrl.in_auto_key_retrieve++;
821                   rc = keyserver_import_name (ctrl, name, &fpr, &fpr_len,
822                                               opt.keyserver);
823                   glo_ctrl.in_auto_key_retrieve--;
824                 }
825               else
826                 {
827                   mechanism = "Unconfigured keyserver";
828                   rc = G10ERR_NO_PUBKEY;
829                 }
830               break;
831
832             case AKL_SPEC:
833               {
834                 struct keyserver_spec *keyserver;
835
836                 mechanism = akl->spec->uri;
837                 keyserver = keyserver_match (akl->spec);
838                 glo_ctrl.in_auto_key_retrieve++;
839                 rc = keyserver_import_name (ctrl,
840                                             name, &fpr, &fpr_len, keyserver);
841                 glo_ctrl.in_auto_key_retrieve--;
842               }
843               break;
844             }
845
846           /* Use the fingerprint of the key that we actually fetched.
847              This helps prevent problems where the key that we fetched
848              doesn't have the same name that we used to fetch it.  In
849              the case of CERT and PKA, this is an actual security
850              requirement as the URL might point to a key put in by an
851              attacker.  By forcing the use of the fingerprint, we
852              won't use the attacker's key here. */
853           if (!rc && fpr)
854             {
855               char fpr_string[MAX_FINGERPRINT_LEN * 2 + 1];
856
857               assert (fpr_len <= MAX_FINGERPRINT_LEN);
858
859               free_strlist (namelist);
860               namelist = NULL;
861
862               bin2hex (fpr, fpr_len, fpr_string);
863
864               if (opt.verbose)
865                 log_info ("auto-key-locate found fingerprint %s\n",
866                           fpr_string);
867
868               add_to_strlist (&namelist, fpr_string);
869             }
870           else if (!rc && !fpr && !did_key_byname)
871             {
872               no_fingerprint = 1;
873               rc = G10ERR_NO_PUBKEY;
874             }
875           xfree (fpr);
876           fpr = NULL;
877
878           if (!rc && !did_key_byname)
879             {
880               if (retctx)
881                 {
882                   get_pubkey_end (*retctx);
883                   *retctx = NULL;
884                 }
885               rc = key_byname (anylocalfirst ? retctx : NULL,
886                                namelist, pk, 0,
887                                include_unusable, ret_keyblock, ret_kdbhd);
888             }
889           if (!rc)
890             {
891               /* Key found.  */
892               log_info (_("automatically retrieved '%s' via %s\n"),
893                         name, mechanism);
894               break;
895             }
896           if (rc != G10ERR_NO_PUBKEY || opt.verbose || no_fingerprint)
897             log_info (_("error retrieving '%s' via %s: %s\n"),
898                       name, mechanism,
899                       no_fingerprint ? _("No fingerprint") : g10_errstr (rc));
900         }
901     }
902
903
904   if (rc && retctx)
905     {
906       get_pubkey_end (*retctx);
907       *retctx = NULL;
908     }
909
910   if (retctx && *retctx)
911     {
912       assert (!(*retctx)->extra_list);
913       (*retctx)->extra_list = namelist;
914     }
915   else
916     free_strlist (namelist);
917   return rc;
918 }
919
920
921 int
922 get_pubkey_bynames (GETKEY_CTX * retctx, PKT_public_key * pk,
923                     strlist_t names, KBNODE * ret_keyblock)
924 {
925   return key_byname (retctx, names, pk, 0, 1, ret_keyblock, NULL);
926 }
927
928 int
929 get_pubkey_next (GETKEY_CTX ctx, PKT_public_key * pk, KBNODE * ret_keyblock)
930 {
931   return gpg_err_code (getkey_next (ctx, pk, ret_keyblock));
932 }
933
934 void
935 get_pubkey_end (GETKEY_CTX ctx)
936 {
937   getkey_end (ctx);
938 }
939
940
941 /* Search for a key with the given standard fingerprint.  In contrast
942  * to get_pubkey_byfprint we assume a right padded fingerprint of the
943  * standard length.  PK may be NULL to only put the result into the
944  * internal caches.  */
945 gpg_error_t
946 get_pubkey_byfpr (PKT_public_key *pk, const byte *fpr)
947 {
948   gpg_error_t err;
949   struct getkey_ctx_s ctx;
950   kbnode_t kb = NULL;
951
952   memset (&ctx, 0, sizeof ctx);
953   ctx.exact = 1;
954   ctx.not_allocated = 1;
955   ctx.kr_handle = keydb_new ();
956   ctx.nitems = 1;
957   ctx.items[0].mode = KEYDB_SEARCH_MODE_FPR;
958   memcpy (ctx.items[0].u.fpr, fpr, MAX_FINGERPRINT_LEN);
959   err = lookup (&ctx, &kb, 0);
960   if (!err && pk)
961     pk_from_block (&ctx, pk, kb);
962   release_kbnode (kb);
963   get_pubkey_end (&ctx);
964
965   return err;
966 }
967
968
969 /* Search for a key with the given fingerprint.
970  * FIXME:
971  * We should replace this with the _byname function.  This can be done
972  * by creating a userID conforming to the unified fingerprint style.
973  */
974 int
975 get_pubkey_byfprint (PKT_public_key * pk,
976                      const byte * fprint, size_t fprint_len)
977 {
978   int rc;
979
980   if (fprint_len == 20 || fprint_len == 16)
981     {
982       struct getkey_ctx_s ctx;
983       KBNODE kb = NULL;
984
985       memset (&ctx, 0, sizeof ctx);
986       ctx.exact = 1;
987       ctx.not_allocated = 1;
988       ctx.kr_handle = keydb_new ();
989       ctx.nitems = 1;
990       ctx.items[0].mode = fprint_len == 16 ? KEYDB_SEARCH_MODE_FPR16
991         : KEYDB_SEARCH_MODE_FPR20;
992       memcpy (ctx.items[0].u.fpr, fprint, fprint_len);
993       rc = lookup (&ctx, &kb, 0);
994       if (!rc && pk)
995         pk_from_block (&ctx, pk, kb);
996       release_kbnode (kb);
997       get_pubkey_end (&ctx);
998     }
999   else
1000     rc = G10ERR_GENERAL; /* Oops */
1001   return rc;
1002 }
1003
1004
1005 /* Get a public key and store it into the allocated pk.  This function
1006    differs from get_pubkey_byfprint() in that it does not do a check
1007    of the key to avoid recursion.  It should be used only in very
1008    certain cases.  PK may be NULL to check just for the existance of
1009    the key.  */
1010 int
1011 get_pubkey_byfprint_fast (PKT_public_key * pk,
1012                           const byte * fprint, size_t fprint_len)
1013 {
1014   int rc = 0;
1015   KEYDB_HANDLE hd;
1016   KBNODE keyblock;
1017   byte fprbuf[MAX_FINGERPRINT_LEN];
1018   int i;
1019
1020   for (i = 0; i < MAX_FINGERPRINT_LEN && i < fprint_len; i++)
1021     fprbuf[i] = fprint[i];
1022   while (i < MAX_FINGERPRINT_LEN)
1023     fprbuf[i++] = 0;
1024
1025   hd = keydb_new ();
1026   rc = keydb_search_fpr (hd, fprbuf);
1027   if (gpg_err_code (rc) == GPG_ERR_NOT_FOUND)
1028     {
1029       keydb_release (hd);
1030       return G10ERR_NO_PUBKEY;
1031     }
1032   rc = keydb_get_keyblock (hd, &keyblock);
1033   keydb_release (hd);
1034   if (rc)
1035     {
1036       log_error ("keydb_get_keyblock failed: %s\n", g10_errstr (rc));
1037       return G10ERR_NO_PUBKEY;
1038     }
1039
1040   assert (keyblock->pkt->pkttype == PKT_PUBLIC_KEY
1041           || keyblock->pkt->pkttype == PKT_PUBLIC_SUBKEY);
1042   if (pk)
1043     copy_public_key (pk, keyblock->pkt->pkt.public_key);
1044   release_kbnode (keyblock);
1045
1046   /* Not caching key here since it won't have all of the fields
1047      properly set. */
1048
1049   return 0;
1050 }
1051
1052
1053 /* Search for a key with the given fingerprint and return the
1054  * complete keyblock which may have more than only this key.   */
1055 int
1056 get_keyblock_byfprint (KBNODE * ret_keyblock, const byte * fprint,
1057                        size_t fprint_len)
1058 {
1059   int rc;
1060
1061   if (fprint_len == 20 || fprint_len == 16)
1062     {
1063       struct getkey_ctx_s ctx;
1064
1065       memset (&ctx, 0, sizeof ctx);
1066       ctx.not_allocated = 1;
1067       ctx.kr_handle = keydb_new ();
1068       ctx.nitems = 1;
1069       ctx.items[0].mode = (fprint_len == 16
1070                            ? KEYDB_SEARCH_MODE_FPR16
1071                            : KEYDB_SEARCH_MODE_FPR20);
1072       memcpy (ctx.items[0].u.fpr, fprint, fprint_len);
1073       rc = lookup (&ctx, ret_keyblock, 0);
1074       get_pubkey_end (&ctx);
1075     }
1076   else
1077     rc = G10ERR_GENERAL; /* Oops */
1078
1079   return rc;
1080 }
1081
1082
1083 /* Get a secret key by NAME and store it into PK.  If NAME is NULL use
1084  * the default key.  This functions checks that a corresponding secret
1085  * key is available.  With no secret key it does not succeeed. */
1086 gpg_error_t
1087 get_seckey_byname (PKT_public_key *pk, const char *name)
1088 {
1089   gpg_error_t err;
1090   strlist_t namelist = NULL;
1091   int include_unusable = 1;
1092
1093   /* If we have no name, try to use the default secret key.  If we
1094      have no default, we'll use the first usable one. */
1095
1096   if (!name && opt.def_secret_key && *opt.def_secret_key)
1097     add_to_strlist (&namelist, opt.def_secret_key);
1098   else if (name)
1099     add_to_strlist (&namelist, name);
1100   else
1101     include_unusable = 0;
1102
1103   err = key_byname (NULL, namelist, pk, 1, include_unusable, NULL, NULL);
1104
1105   free_strlist (namelist);
1106
1107   return err;
1108 }
1109
1110
1111
1112 /* Search for a key with the given fingerprint.
1113  * FIXME:
1114  * We should replace this with the _byname function.  This can be done
1115  * by creating a userID conforming to the unified fingerprint style.   */
1116 gpg_error_t
1117 get_seckey_byfprint (PKT_public_key *pk, const byte * fprint, size_t fprint_len)
1118 {
1119   gpg_error_t err;
1120
1121   if (fprint_len == 20 || fprint_len == 16)
1122     {
1123       struct getkey_ctx_s ctx;
1124       kbnode_t kb = NULL;
1125
1126       memset (&ctx, 0, sizeof ctx);
1127       ctx.exact = 1;
1128       ctx.not_allocated = 1;
1129       ctx.kr_handle = keydb_new ();
1130       ctx.nitems = 1;
1131       ctx.items[0].mode = fprint_len == 16 ? KEYDB_SEARCH_MODE_FPR16
1132         : KEYDB_SEARCH_MODE_FPR20;
1133       memcpy (ctx.items[0].u.fpr, fprint, fprint_len);
1134       err = lookup (&ctx, &kb, 1);
1135       if (!err && pk)
1136         pk_from_block (&ctx, pk, kb);
1137       release_kbnode (kb);
1138       get_pubkey_end (&ctx);
1139     }
1140   else
1141     err = gpg_error (GPG_ERR_BUG);
1142   return err;
1143 }
1144
1145
1146 /* Search for a secret key with the given fingerprint and return the
1147    complete keyblock which may have more than only this key.  Return
1148    an error if no corresponding secret key is available.  */
1149 gpg_error_t
1150 get_seckeyblock_byfprint (kbnode_t *ret_keyblock,
1151                           const byte *fprint, size_t fprint_len)
1152 {
1153   gpg_error_t err;
1154   struct getkey_ctx_s ctx;
1155
1156   if (fprint_len != 20 && fprint_len == 16)
1157     return gpg_error (GPG_ERR_BUG);
1158
1159   memset (&ctx, 0, sizeof ctx);
1160   ctx.not_allocated = 1;
1161   ctx.kr_handle = keydb_new ();
1162   ctx.nitems = 1;
1163   ctx.items[0].mode = (fprint_len == 16
1164                        ? KEYDB_SEARCH_MODE_FPR16 : KEYDB_SEARCH_MODE_FPR20);
1165   memcpy (ctx.items[0].u.fpr, fprint, fprint_len);
1166   err = lookup (&ctx, ret_keyblock, 1);
1167   get_pubkey_end (&ctx);
1168
1169   return err;
1170 }
1171
1172
1173 \f
1174 /* The new function to return a key.
1175    FIXME: Document it.  */
1176 gpg_error_t
1177 getkey_bynames (getkey_ctx_t *retctx, PKT_public_key *pk,
1178                 strlist_t names, int want_secret, kbnode_t *ret_keyblock)
1179 {
1180   return key_byname (retctx, names, pk, want_secret, 1,
1181                      ret_keyblock, NULL);
1182 }
1183
1184
1185 /* Get a key by name and store it into PK if that is not NULL.  If
1186  * RETCTX is not NULL return the search context which needs to be
1187  * released by the caller using getkey_end.  If NAME is NULL use the
1188  * default key (see below).  On success and if RET_KEYBLOCK is not
1189  * NULL the found keyblock is stored at this address.  WANT_SECRET
1190  * passed as true requires that a secret key is available for the
1191  * selected key.
1192  *
1193  * If WANT_SECRET is true and NAME is NULL and a default key has been
1194  * defined that defined key is used.  In all other cases the first
1195  * available key is used.
1196  *
1197  * FIXME: Explain what is up with unusable keys.
1198  *
1199  * FIXME: We also have the get_pubkey_byname function which has a
1200  * different semantic.  Should be merged with this one.
1201  */
1202 gpg_error_t
1203 getkey_byname (getkey_ctx_t *retctx, PKT_public_key *pk,
1204                const char *name, int want_secret, kbnode_t *ret_keyblock)
1205 {
1206   gpg_error_t err;
1207   strlist_t namelist = NULL;
1208   int with_unusable = 1;
1209
1210   if (want_secret && !name && opt.def_secret_key && *opt.def_secret_key)
1211     add_to_strlist (&namelist, opt.def_secret_key);
1212   else if (name)
1213     add_to_strlist (&namelist, name);
1214   else
1215     with_unusable = 0;
1216
1217   err = key_byname (retctx, namelist, pk, want_secret, with_unusable,
1218                     ret_keyblock, NULL);
1219
1220   /* FIXME: Check that we really return GPG_ERR_NO_SECKEY if
1221      WANT_SECRET has been used.  */
1222
1223   free_strlist (namelist);
1224
1225   return err;
1226 }
1227
1228
1229 /* The new function to return the next key.  */
1230 gpg_error_t
1231 getkey_next (getkey_ctx_t ctx, PKT_public_key *pk, kbnode_t *ret_keyblock)
1232 {
1233   int rc; /* Fixme:  Make sure this is proper gpg_error */
1234
1235   rc = lookup (ctx, ret_keyblock, ctx->want_secret);
1236   if (!rc && pk && ret_keyblock)
1237     pk_from_block (ctx, pk, *ret_keyblock);
1238
1239   return rc;
1240 }
1241
1242
1243 /* The new function to finish a key listing.  */
1244 void
1245 getkey_end (getkey_ctx_t ctx)
1246 {
1247   if (ctx)
1248     {
1249       memset (&ctx->kbpos, 0, sizeof ctx->kbpos);
1250       keydb_release (ctx->kr_handle);
1251       free_strlist (ctx->extra_list);
1252       if (!ctx->not_allocated)
1253         xfree (ctx);
1254     }
1255 }
1256
1257
1258 \f
1259 /************************************************
1260  ************* Merging stuff ********************
1261  ************************************************/
1262
1263 /* Set the mainkey_id fields for all keys in KEYBLOCK.  This is
1264    usually done by merge_selfsigs but at some places we only need the
1265    main_kid but the the full merging.  The function also guarantees
1266    that all pk->keyids are computed. */
1267 void
1268 setup_main_keyids (kbnode_t keyblock)
1269 {
1270   u32 kid[2], mainkid[2];
1271   kbnode_t kbctx, node;
1272   PKT_public_key *pk;
1273
1274   if (keyblock->pkt->pkttype != PKT_PUBLIC_KEY)
1275     BUG ();
1276   pk = keyblock->pkt->pkt.public_key;
1277
1278   keyid_from_pk (pk, mainkid);
1279   for (kbctx=NULL; (node = walk_kbnode (keyblock, &kbctx, 0)); )
1280     {
1281       if (!(node->pkt->pkttype == PKT_PUBLIC_KEY
1282             || node->pkt->pkttype == PKT_PUBLIC_SUBKEY))
1283         continue;
1284       pk = node->pkt->pkt.public_key;
1285       keyid_from_pk (pk, kid); /* Make sure pk->keyid is set.  */
1286       if (!pk->main_keyid[0] && !pk->main_keyid[1])
1287         {
1288           pk->main_keyid[0] = mainkid[0];
1289           pk->main_keyid[1] = mainkid[1];
1290         }
1291     }
1292 }
1293
1294
1295 /* Merge all self-signatures with the keys.  */
1296 void
1297 merge_keys_and_selfsig (KBNODE keyblock)
1298 {
1299   if (!keyblock)
1300     ;
1301   else if (keyblock->pkt->pkttype == PKT_PUBLIC_KEY)
1302     merge_selfsigs (keyblock);
1303   else
1304     log_debug ("FIXME: merging secret key blocks is not anymore available\n");
1305 }
1306
1307
1308 static int
1309 parse_key_usage (PKT_signature * sig)
1310 {
1311   int key_usage = 0;
1312   const byte *p;
1313   size_t n;
1314   byte flags;
1315
1316   p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_KEY_FLAGS, &n);
1317   if (p && n)
1318     {
1319       /* First octet of the keyflags.  */
1320       flags = *p;
1321
1322       if (flags & 1)
1323         {
1324           key_usage |= PUBKEY_USAGE_CERT;
1325           flags &= ~1;
1326         }
1327
1328       if (flags & 2)
1329         {
1330           key_usage |= PUBKEY_USAGE_SIG;
1331           flags &= ~2;
1332         }
1333
1334       /* We do not distinguish between encrypting communications and
1335          encrypting storage. */
1336       if (flags & (0x04 | 0x08))
1337         {
1338           key_usage |= PUBKEY_USAGE_ENC;
1339           flags &= ~(0x04 | 0x08);
1340         }
1341
1342       if (flags & 0x20)
1343         {
1344           key_usage |= PUBKEY_USAGE_AUTH;
1345           flags &= ~0x20;
1346         }
1347
1348       if (flags)
1349         key_usage |= PUBKEY_USAGE_UNKNOWN;
1350
1351       if (!key_usage)
1352         key_usage |= PUBKEY_USAGE_NONE;
1353     }
1354   else if (p) /* Key flags of length zero.  */
1355     key_usage |= PUBKEY_USAGE_NONE;
1356
1357   /* We set PUBKEY_USAGE_UNKNOWN to indicate that this key has a
1358      capability that we do not handle.  This serves to distinguish
1359      between a zero key usage which we handle as the default
1360      capabilities for that algorithm, and a usage that we do not
1361      handle.  Likewise we use PUBKEY_USAGE_NONE to indicate that
1362      key_flags have been given but they do not specify any usage.  */
1363
1364   return key_usage;
1365 }
1366
1367
1368 /* Apply information from SIGNODE (which is the valid self-signature
1369  * associated with that UID) to the UIDNODE:
1370  * - wether the UID has been revoked
1371  * - assumed creation date of the UID
1372  * - temporary store the keyflags here
1373  * - temporary store the key expiration time here
1374  * - mark whether the primary user ID flag hat been set.
1375  * - store the preferences
1376  */
1377 static void
1378 fixup_uidnode (KBNODE uidnode, KBNODE signode, u32 keycreated)
1379 {
1380   PKT_user_id *uid = uidnode->pkt->pkt.user_id;
1381   PKT_signature *sig = signode->pkt->pkt.signature;
1382   const byte *p, *sym, *hash, *zip;
1383   size_t n, nsym, nhash, nzip;
1384
1385   sig->flags.chosen_selfsig = 1;/* We chose this one. */
1386   uid->created = 0;             /* Not created == invalid. */
1387   if (IS_UID_REV (sig))
1388     {
1389       uid->is_revoked = 1;
1390       return; /* Has been revoked.  */
1391     }
1392   else
1393     uid->is_revoked = 0;
1394
1395   uid->expiredate = sig->expiredate;
1396
1397   if (sig->flags.expired)
1398     {
1399       uid->is_expired = 1;
1400       return; /* Has expired.  */
1401     }
1402   else
1403     uid->is_expired = 0;
1404
1405   uid->created = sig->timestamp; /* This one is okay. */
1406   uid->selfsigversion = sig->version;
1407   /* If we got this far, it's not expired :) */
1408   uid->is_expired = 0;
1409
1410   /* Store the key flags in the helper variable for later processing.  */
1411   uid->help_key_usage = parse_key_usage (sig);
1412
1413   /* Ditto for the key expiration.  */
1414   p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_KEY_EXPIRE, NULL);
1415   if (p && buffer_to_u32 (p))
1416     uid->help_key_expire = keycreated + buffer_to_u32 (p);
1417   else
1418     uid->help_key_expire = 0;
1419
1420   /* Set the primary user ID flag - we will later wipe out some
1421    * of them to only have one in our keyblock.  */
1422   uid->is_primary = 0;
1423   p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_PRIMARY_UID, NULL);
1424   if (p && *p)
1425     uid->is_primary = 2;
1426
1427   /* We could also query this from the unhashed area if it is not in
1428    * the hased area and then later try to decide which is the better
1429    * there should be no security problem with this.
1430    * For now we only look at the hashed one.  */
1431
1432   /* Now build the preferences list.  These must come from the
1433      hashed section so nobody can modify the ciphers a key is
1434      willing to accept.  */
1435   p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_PREF_SYM, &n);
1436   sym = p;
1437   nsym = p ? n : 0;
1438   p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_PREF_HASH, &n);
1439   hash = p;
1440   nhash = p ? n : 0;
1441   p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_PREF_COMPR, &n);
1442   zip = p;
1443   nzip = p ? n : 0;
1444   if (uid->prefs)
1445     xfree (uid->prefs);
1446   n = nsym + nhash + nzip;
1447   if (!n)
1448     uid->prefs = NULL;
1449   else
1450     {
1451       uid->prefs = xmalloc (sizeof (*uid->prefs) * (n + 1));
1452       n = 0;
1453       for (; nsym; nsym--, n++)
1454         {
1455           uid->prefs[n].type = PREFTYPE_SYM;
1456           uid->prefs[n].value = *sym++;
1457         }
1458       for (; nhash; nhash--, n++)
1459         {
1460           uid->prefs[n].type = PREFTYPE_HASH;
1461           uid->prefs[n].value = *hash++;
1462         }
1463       for (; nzip; nzip--, n++)
1464         {
1465           uid->prefs[n].type = PREFTYPE_ZIP;
1466           uid->prefs[n].value = *zip++;
1467         }
1468       uid->prefs[n].type = PREFTYPE_NONE; /* End of list marker  */
1469       uid->prefs[n].value = 0;
1470     }
1471
1472   /* See whether we have the MDC feature.  */
1473   uid->flags.mdc = 0;
1474   p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_FEATURES, &n);
1475   if (p && n && (p[0] & 0x01))
1476     uid->flags.mdc = 1;
1477
1478   /* And the keyserver modify flag.  */
1479   uid->flags.ks_modify = 1;
1480   p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_KS_FLAGS, &n);
1481   if (p && n && (p[0] & 0x80))
1482     uid->flags.ks_modify = 0;
1483 }
1484
1485 static void
1486 sig_to_revoke_info (PKT_signature * sig, struct revoke_info *rinfo)
1487 {
1488   rinfo->date = sig->timestamp;
1489   rinfo->algo = sig->pubkey_algo;
1490   rinfo->keyid[0] = sig->keyid[0];
1491   rinfo->keyid[1] = sig->keyid[1];
1492 }
1493
1494
1495 /* Note that R_REVOKED may be set to 0, 1 or 2.  */
1496 static void
1497 merge_selfsigs_main (KBNODE keyblock, int *r_revoked,
1498                      struct revoke_info *rinfo)
1499 {
1500   PKT_public_key *pk = NULL;
1501   KBNODE k;
1502   u32 kid[2];
1503   u32 sigdate, uiddate, uiddate2;
1504   KBNODE signode, uidnode, uidnode2;
1505   u32 curtime = make_timestamp ();
1506   unsigned int key_usage = 0;
1507   u32 keytimestamp = 0;
1508   u32 key_expire = 0;
1509   int key_expire_seen = 0;
1510   byte sigversion = 0;
1511
1512   *r_revoked = 0;
1513   memset (rinfo, 0, sizeof (*rinfo));
1514
1515   if (keyblock->pkt->pkttype != PKT_PUBLIC_KEY)
1516     BUG ();
1517   pk = keyblock->pkt->pkt.public_key;
1518   keytimestamp = pk->timestamp;
1519
1520   keyid_from_pk (pk, kid);
1521   pk->main_keyid[0] = kid[0];
1522   pk->main_keyid[1] = kid[1];
1523
1524   if (pk->version < 4)
1525     {
1526       /* Before v4 the key packet itself contains the expiration date
1527        * and there was no way to change it, so we start with the one
1528        * from the key packet.  */
1529       key_expire = pk->max_expiredate;
1530       key_expire_seen = 1;
1531     }
1532
1533   /* First pass: Find the latest direct key self-signature.  We assume
1534    * that the newest one overrides all others.  */
1535
1536   /* In case this key was already merged. */
1537   xfree (pk->revkey);
1538   pk->revkey = NULL;
1539   pk->numrevkeys = 0;
1540
1541   signode = NULL;
1542   sigdate = 0; /* Helper variable to find the latest signature.  */
1543   for (k = keyblock; k && k->pkt->pkttype != PKT_USER_ID; k = k->next)
1544     {
1545       if (k->pkt->pkttype == PKT_SIGNATURE)
1546         {
1547           PKT_signature *sig = k->pkt->pkt.signature;
1548           if (sig->keyid[0] == kid[0] && sig->keyid[1] == kid[1])
1549             {
1550               if (check_key_signature (keyblock, k, NULL))
1551                 ; /* Signature did not verify.  */
1552               else if (IS_KEY_REV (sig))
1553                 {
1554                   /* Key has been revoked - there is no way to
1555                    * override such a revocation, so we theoretically
1556                    * can stop now.  We should not cope with expiration
1557                    * times for revocations here because we have to
1558                    * assume that an attacker can generate all kinds of
1559                    * signatures.  However due to the fact that the key
1560                    * has been revoked it does not harm either and by
1561                    * continuing we gather some more info on that
1562                    * key.  */
1563                   *r_revoked = 1;
1564                   sig_to_revoke_info (sig, rinfo);
1565                 }
1566               else if (IS_KEY_SIG (sig))
1567                 {
1568                   /* Add any revocation keys onto the pk.  This is
1569                      particularly interesting since we normally only
1570                      get data from the most recent 1F signature, but
1571                      you need multiple 1F sigs to properly handle
1572                      revocation keys (PGP does it this way, and a
1573                      revocation key could be sensitive and hence in a
1574                      different signature). */
1575                   if (sig->revkey)
1576                     {
1577                       int i;
1578
1579                       pk->revkey =
1580                         xrealloc (pk->revkey, sizeof (struct revocation_key) *
1581                                   (pk->numrevkeys + sig->numrevkeys));
1582
1583                       for (i = 0; i < sig->numrevkeys; i++)
1584                         memcpy (&pk->revkey[pk->numrevkeys++],
1585                                 sig->revkey[i],
1586                                 sizeof (struct revocation_key));
1587                     }
1588
1589                   if (sig->timestamp >= sigdate)
1590                     {
1591                       if (sig->flags.expired)
1592                         ; /* Signature has expired - ignore it.  */
1593                       else
1594                         {
1595                           sigdate = sig->timestamp;
1596                           signode = k;
1597                           if (sig->version > sigversion)
1598                             sigversion = sig->version;
1599
1600                         }
1601                     }
1602                 }
1603             }
1604         }
1605     }
1606
1607   /* Remove dupes from the revocation keys.  */
1608
1609   if (pk->revkey)
1610     {
1611       int i, j, x, changed = 0;
1612
1613       for (i = 0; i < pk->numrevkeys; i++)
1614         {
1615           for (j = i + 1; j < pk->numrevkeys; j++)
1616             {
1617               if (memcmp (&pk->revkey[i], &pk->revkey[j],
1618                           sizeof (struct revocation_key)) == 0)
1619                 {
1620                   /* remove j */
1621
1622                   for (x = j; x < pk->numrevkeys - 1; x++)
1623                     pk->revkey[x] = pk->revkey[x + 1];
1624
1625                   pk->numrevkeys--;
1626                   j--;
1627                   changed = 1;
1628                 }
1629             }
1630         }
1631
1632       if (changed)
1633         pk->revkey = xrealloc (pk->revkey,
1634                                pk->numrevkeys *
1635                                sizeof (struct revocation_key));
1636     }
1637
1638   if (signode)
1639     {
1640       /* Some information from a direct key signature take precedence
1641        * over the same information given in UID sigs.  */
1642       PKT_signature *sig = signode->pkt->pkt.signature;
1643       const byte *p;
1644
1645       key_usage = parse_key_usage (sig);
1646
1647       p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_KEY_EXPIRE, NULL);
1648       if (p && buffer_to_u32 (p))
1649         {
1650           key_expire = keytimestamp + buffer_to_u32 (p);
1651           key_expire_seen = 1;
1652         }
1653
1654       /* Mark that key as valid: One direct key signature should
1655        * render a key as valid.  */
1656       pk->flags.valid = 1;
1657     }
1658
1659   /* Pass 1.5: Look for key revocation signatures that were not made
1660      by the key (i.e. did a revocation key issue a revocation for
1661      us?).  Only bother to do this if there is a revocation key in the
1662      first place and we're not revoked already.  */
1663
1664   if (!*r_revoked && pk->revkey)
1665     for (k = keyblock; k && k->pkt->pkttype != PKT_USER_ID; k = k->next)
1666       {
1667         if (k->pkt->pkttype == PKT_SIGNATURE)
1668           {
1669             PKT_signature *sig = k->pkt->pkt.signature;
1670
1671             if (IS_KEY_REV (sig) &&
1672                 (sig->keyid[0] != kid[0] || sig->keyid[1] != kid[1]))
1673               {
1674                 int rc = check_revocation_keys (pk, sig);
1675                 if (rc == 0)
1676                   {
1677                     *r_revoked = 2;
1678                     sig_to_revoke_info (sig, rinfo);
1679                     /* Don't continue checking since we can't be any
1680                        more revoked than this.  */
1681                     break;
1682                   }
1683                 else if (rc == G10ERR_NO_PUBKEY)
1684                   pk->flags.maybe_revoked = 1;
1685
1686                 /* A failure here means the sig did not verify, was
1687                    not issued by a revocation key, or a revocation
1688                    key loop was broken.  If a revocation key isn't
1689                    findable, however, the key might be revoked and
1690                    we don't know it.  */
1691
1692                 /* TODO: In the future handle subkey and cert
1693                    revocations?  PGP doesn't, but it's in 2440. */
1694               }
1695           }
1696       }
1697
1698   /* Second pass: Look at the self-signature of all user IDs.  */
1699   signode = uidnode = NULL;
1700   sigdate = 0; /* Helper variable to find the latest signature in one UID. */
1701   for (k = keyblock; k && k->pkt->pkttype != PKT_PUBLIC_SUBKEY; k = k->next)
1702     {
1703       if (k->pkt->pkttype == PKT_USER_ID)
1704         {
1705           if (uidnode && signode)
1706             {
1707               fixup_uidnode (uidnode, signode, keytimestamp);
1708               pk->flags.valid = 1;
1709             }
1710           uidnode = k;
1711           signode = NULL;
1712           sigdate = 0;
1713         }
1714       else if (k->pkt->pkttype == PKT_SIGNATURE && uidnode)
1715         {
1716           PKT_signature *sig = k->pkt->pkt.signature;
1717           if (sig->keyid[0] == kid[0] && sig->keyid[1] == kid[1])
1718             {
1719               if (check_key_signature (keyblock, k, NULL))
1720                 ;               /* signature did not verify */
1721               else if ((IS_UID_SIG (sig) || IS_UID_REV (sig))
1722                        && sig->timestamp >= sigdate)
1723                 {
1724                   /* Note: we allow to invalidate cert revocations
1725                    * by a newer signature.  An attacker can't use this
1726                    * because a key should be revoced with a key revocation.
1727                    * The reason why we have to allow for that is that at
1728                    * one time an email address may become invalid but later
1729                    * the same email address may become valid again (hired,
1730                    * fired, hired again).  */
1731
1732                   sigdate = sig->timestamp;
1733                   signode = k;
1734                   signode->pkt->pkt.signature->flags.chosen_selfsig = 0;
1735                   if (sig->version > sigversion)
1736                     sigversion = sig->version;
1737                 }
1738             }
1739         }
1740     }
1741   if (uidnode && signode)
1742     {
1743       fixup_uidnode (uidnode, signode, keytimestamp);
1744       pk->flags.valid = 1;
1745     }
1746
1747   /* If the key isn't valid yet, and we have
1748      --allow-non-selfsigned-uid set, then force it valid. */
1749   if (!pk->flags.valid && opt.allow_non_selfsigned_uid)
1750     {
1751       if (opt.verbose)
1752         log_info (_("Invalid key %s made valid by"
1753                     " --allow-non-selfsigned-uid\n"), keystr_from_pk (pk));
1754       pk->flags.valid = 1;
1755     }
1756
1757   /* The key STILL isn't valid, so try and find an ultimately
1758      trusted signature. */
1759   if (!pk->flags.valid)
1760     {
1761       uidnode = NULL;
1762
1763       for (k = keyblock; k && k->pkt->pkttype != PKT_PUBLIC_SUBKEY;
1764            k = k->next)
1765         {
1766           if (k->pkt->pkttype == PKT_USER_ID)
1767             uidnode = k;
1768           else if (k->pkt->pkttype == PKT_SIGNATURE && uidnode)
1769             {
1770               PKT_signature *sig = k->pkt->pkt.signature;
1771
1772               if (sig->keyid[0] != kid[0] || sig->keyid[1] != kid[1])
1773                 {
1774                   PKT_public_key *ultimate_pk;
1775
1776                   ultimate_pk = xmalloc_clear (sizeof (*ultimate_pk));
1777
1778                   /* We don't want to use the full get_pubkey to
1779                      avoid infinite recursion in certain cases.
1780                      There is no reason to check that an ultimately
1781                      trusted key is still valid - if it has been
1782                      revoked or the user should also renmove the
1783                      ultimate trust flag.  */
1784                   if (get_pubkey_fast (ultimate_pk, sig->keyid) == 0
1785                       && check_key_signature2 (keyblock, k, ultimate_pk,
1786                                                NULL, NULL, NULL, NULL) == 0
1787                       && get_ownertrust (ultimate_pk) == TRUST_ULTIMATE)
1788                     {
1789                       free_public_key (ultimate_pk);
1790                       pk->flags.valid = 1;
1791                       break;
1792                     }
1793
1794                   free_public_key (ultimate_pk);
1795                 }
1796             }
1797         }
1798     }
1799
1800   /* Record the highest selfsig version so we know if this is a v3
1801      key through and through, or a v3 key with a v4 selfsig
1802      somewhere.  This is useful in a few places to know if the key
1803      must be treated as PGP2-style or OpenPGP-style.  Note that a
1804      selfsig revocation with a higher version number will also raise
1805      this value.  This is okay since such a revocation must be
1806      issued by the user (i.e. it cannot be issued by someone else to
1807      modify the key behavior.) */
1808
1809   pk->selfsigversion = sigversion;
1810
1811   /* Now that we had a look at all user IDs we can now get some information
1812    * from those user IDs.
1813    */
1814
1815   if (!key_usage)
1816     {
1817       /* Find the latest user ID with key flags set. */
1818       uiddate = 0; /* Helper to find the latest user ID.  */
1819       for (k = keyblock; k && k->pkt->pkttype != PKT_PUBLIC_SUBKEY;
1820            k = k->next)
1821         {
1822           if (k->pkt->pkttype == PKT_USER_ID)
1823             {
1824               PKT_user_id *uid = k->pkt->pkt.user_id;
1825               if (uid->help_key_usage && uid->created > uiddate)
1826                 {
1827                   key_usage = uid->help_key_usage;
1828                   uiddate = uid->created;
1829                 }
1830             }
1831         }
1832     }
1833   if (!key_usage)
1834     {
1835       /* No key flags at all: get it from the algo.  */
1836       key_usage = openpgp_pk_algo_usage (pk->pubkey_algo);
1837     }
1838   else
1839     {
1840       /* Check that the usage matches the usage as given by the algo.  */
1841       int x = openpgp_pk_algo_usage (pk->pubkey_algo);
1842       if (x) /* Mask it down to the actual allowed usage.  */
1843         key_usage &= x;
1844     }
1845
1846   /* Whatever happens, it's a primary key, so it can certify. */
1847   pk->pubkey_usage = key_usage | PUBKEY_USAGE_CERT;
1848
1849   if (!key_expire_seen)
1850     {
1851       /* Find the latest valid user ID with a key expiration set
1852        * Note, that this may be a different one from the above because
1853        * some user IDs may have no expiration date set.  */
1854       uiddate = 0;
1855       for (k = keyblock; k && k->pkt->pkttype != PKT_PUBLIC_SUBKEY;
1856            k = k->next)
1857         {
1858           if (k->pkt->pkttype == PKT_USER_ID)
1859             {
1860               PKT_user_id *uid = k->pkt->pkt.user_id;
1861               if (uid->help_key_expire && uid->created > uiddate)
1862                 {
1863                   key_expire = uid->help_key_expire;
1864                   uiddate = uid->created;
1865                 }
1866             }
1867         }
1868     }
1869
1870   /* Currently only v3 keys have a maximum expiration date, but I'll
1871      bet v5 keys get this feature again. */
1872   if (key_expire == 0
1873       || (pk->max_expiredate && key_expire > pk->max_expiredate))
1874     key_expire = pk->max_expiredate;
1875
1876   pk->has_expired = key_expire >= curtime ? 0 : key_expire;
1877   pk->expiredate = key_expire;
1878
1879   /* Fixme: we should see how to get rid of the expiretime fields  but
1880    * this needs changes at other places too. */
1881
1882   /* And now find the real primary user ID and delete all others.  */
1883   uiddate = uiddate2 = 0;
1884   uidnode = uidnode2 = NULL;
1885   for (k = keyblock; k && k->pkt->pkttype != PKT_PUBLIC_SUBKEY; k = k->next)
1886     {
1887       if (k->pkt->pkttype == PKT_USER_ID && !k->pkt->pkt.user_id->attrib_data)
1888         {
1889           PKT_user_id *uid = k->pkt->pkt.user_id;
1890           if (uid->is_primary)
1891             {
1892               if (uid->created > uiddate)
1893                 {
1894                   uiddate = uid->created;
1895                   uidnode = k;
1896                 }
1897               else if (uid->created == uiddate && uidnode)
1898                 {
1899                   /* The dates are equal, so we need to do a
1900                      different (and arbitrary) comparison.  This
1901                      should rarely, if ever, happen.  It's good to
1902                      try and guarantee that two different GnuPG
1903                      users with two different keyrings at least pick
1904                      the same primary. */
1905                   if (cmp_user_ids (uid, uidnode->pkt->pkt.user_id) > 0)
1906                     uidnode = k;
1907                 }
1908             }
1909           else
1910             {
1911               if (uid->created > uiddate2)
1912                 {
1913                   uiddate2 = uid->created;
1914                   uidnode2 = k;
1915                 }
1916               else if (uid->created == uiddate2 && uidnode2)
1917                 {
1918                   if (cmp_user_ids (uid, uidnode2->pkt->pkt.user_id) > 0)
1919                     uidnode2 = k;
1920                 }
1921             }
1922         }
1923     }
1924   if (uidnode)
1925     {
1926       for (k = keyblock; k && k->pkt->pkttype != PKT_PUBLIC_SUBKEY;
1927            k = k->next)
1928         {
1929           if (k->pkt->pkttype == PKT_USER_ID &&
1930               !k->pkt->pkt.user_id->attrib_data)
1931             {
1932               PKT_user_id *uid = k->pkt->pkt.user_id;
1933               if (k != uidnode)
1934                 uid->is_primary = 0;
1935             }
1936         }
1937     }
1938   else if (uidnode2)
1939     {
1940       /* None is flagged primary - use the latest user ID we have,
1941          and disambiguate with the arbitrary packet comparison. */
1942       uidnode2->pkt->pkt.user_id->is_primary = 1;
1943     }
1944   else
1945     {
1946       /* None of our uids were self-signed, so pick the one that
1947          sorts first to be the primary.  This is the best we can do
1948          here since there are no self sigs to date the uids. */
1949
1950       uidnode = NULL;
1951
1952       for (k = keyblock; k && k->pkt->pkttype != PKT_PUBLIC_SUBKEY;
1953            k = k->next)
1954         {
1955           if (k->pkt->pkttype == PKT_USER_ID
1956               && !k->pkt->pkt.user_id->attrib_data)
1957             {
1958               if (!uidnode)
1959                 {
1960                   uidnode = k;
1961                   uidnode->pkt->pkt.user_id->is_primary = 1;
1962                   continue;
1963                 }
1964               else
1965                 {
1966                   if (cmp_user_ids (k->pkt->pkt.user_id,
1967                                     uidnode->pkt->pkt.user_id) > 0)
1968                     {
1969                       uidnode->pkt->pkt.user_id->is_primary = 0;
1970                       uidnode = k;
1971                       uidnode->pkt->pkt.user_id->is_primary = 1;
1972                     }
1973                   else
1974                     k->pkt->pkt.user_id->is_primary = 0;        /* just to be
1975                                                                    safe */
1976                 }
1977             }
1978         }
1979     }
1980 }
1981
1982 /* Convert a buffer to a signature.  Useful for 0x19 embedded sigs.
1983    Caller must free the signature when they are done. */
1984 static PKT_signature *
1985 buf_to_sig (const byte * buf, size_t len)
1986 {
1987   PKT_signature *sig = xmalloc_clear (sizeof (PKT_signature));
1988   IOBUF iobuf = iobuf_temp_with_content (buf, len);
1989   int save_mode = set_packet_list_mode (0);
1990
1991   if (parse_signature (iobuf, PKT_SIGNATURE, len, sig) != 0)
1992     {
1993       xfree (sig);
1994       sig = NULL;
1995     }
1996
1997   set_packet_list_mode (save_mode);
1998   iobuf_close (iobuf);
1999
2000   return sig;
2001 }
2002
2003 static void
2004 merge_selfsigs_subkey (KBNODE keyblock, KBNODE subnode)
2005 {
2006   PKT_public_key *mainpk = NULL, *subpk = NULL;
2007   PKT_signature *sig;
2008   KBNODE k;
2009   u32 mainkid[2];
2010   u32 sigdate = 0;
2011   KBNODE signode;
2012   u32 curtime = make_timestamp ();
2013   unsigned int key_usage = 0;
2014   u32 keytimestamp = 0;
2015   u32 key_expire = 0;
2016   const byte *p;
2017
2018   if (subnode->pkt->pkttype != PKT_PUBLIC_SUBKEY)
2019     BUG ();
2020   mainpk = keyblock->pkt->pkt.public_key;
2021   if (mainpk->version < 4)
2022     return;/* (actually this should never happen) */
2023   keyid_from_pk (mainpk, mainkid);
2024   subpk = subnode->pkt->pkt.public_key;
2025   keytimestamp = subpk->timestamp;
2026
2027   subpk->flags.valid = 0;
2028   subpk->main_keyid[0] = mainpk->main_keyid[0];
2029   subpk->main_keyid[1] = mainpk->main_keyid[1];
2030
2031   /* Find the latest key binding self-signature.  */
2032   signode = NULL;
2033   sigdate = 0; /* Helper to find the latest signature.  */
2034   for (k = subnode->next; k && k->pkt->pkttype != PKT_PUBLIC_SUBKEY;
2035        k = k->next)
2036     {
2037       if (k->pkt->pkttype == PKT_SIGNATURE)
2038         {
2039           sig = k->pkt->pkt.signature;
2040           if (sig->keyid[0] == mainkid[0] && sig->keyid[1] == mainkid[1])
2041             {
2042               if (check_key_signature (keyblock, k, NULL))
2043                 ; /* Signature did not verify.  */
2044               else if (IS_SUBKEY_REV (sig))
2045                 {
2046                   /* Note that this means that the date on a
2047                      revocation sig does not matter - even if the
2048                      binding sig is dated after the revocation sig,
2049                      the subkey is still marked as revoked.  This
2050                      seems ok, as it is just as easy to make new
2051                      subkeys rather than re-sign old ones as the
2052                      problem is in the distribution.  Plus, PGP (7)
2053                      does this the same way.  */
2054                   subpk->flags.revoked = 1;
2055                   sig_to_revoke_info (sig, &subpk->revoked);
2056                   /* Although we could stop now, we continue to
2057                    * figure out other information like the old expiration
2058                    * time.  */
2059                 }
2060               else if (IS_SUBKEY_SIG (sig) && sig->timestamp >= sigdate)
2061                 {
2062                   if (sig->flags.expired)
2063                     ; /* Signature has expired - ignore it.  */
2064                   else
2065                     {
2066                       sigdate = sig->timestamp;
2067                       signode = k;
2068                       signode->pkt->pkt.signature->flags.chosen_selfsig = 0;
2069                     }
2070                 }
2071             }
2072         }
2073     }
2074
2075   /* No valid key binding.  */
2076   if (!signode)
2077     return;
2078
2079   sig = signode->pkt->pkt.signature;
2080   sig->flags.chosen_selfsig = 1; /* So we know which selfsig we chose later.  */
2081
2082   key_usage = parse_key_usage (sig);
2083   if (!key_usage)
2084     {
2085       /* No key flags at all: get it from the algo.  */
2086       key_usage = openpgp_pk_algo_usage (subpk->pubkey_algo);
2087     }
2088   else
2089     {
2090       /* Check that the usage matches the usage as given by the algo.  */
2091       int x = openpgp_pk_algo_usage (subpk->pubkey_algo);
2092       if (x) /* Mask it down to the actual allowed usage.  */
2093         key_usage &= x;
2094     }
2095
2096   subpk->pubkey_usage = key_usage;
2097
2098   p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_KEY_EXPIRE, NULL);
2099   if (p && buffer_to_u32 (p))
2100     key_expire = keytimestamp + buffer_to_u32 (p);
2101   else
2102     key_expire = 0;
2103   subpk->has_expired = key_expire >= curtime ? 0 : key_expire;
2104   subpk->expiredate = key_expire;
2105
2106   /* Algo doesn't exist.  */
2107   if (openpgp_pk_test_algo (subpk->pubkey_algo))
2108     return;
2109
2110   subpk->flags.valid = 1;
2111
2112   /* Find the most recent 0x19 embedded signature on our self-sig. */
2113   if (!subpk->flags.backsig)
2114     {
2115       int seq = 0;
2116       size_t n;
2117       PKT_signature *backsig = NULL;
2118
2119       sigdate = 0;
2120
2121       /* We do this while() since there may be other embedded
2122          signatures in the future.  We only want 0x19 here. */
2123
2124       while ((p = enum_sig_subpkt (sig->hashed,
2125                                    SIGSUBPKT_SIGNATURE, &n, &seq, NULL)))
2126         if (n > 3
2127             && ((p[0] == 3 && p[2] == 0x19) || (p[0] == 4 && p[1] == 0x19)))
2128           {
2129             PKT_signature *tempsig = buf_to_sig (p, n);
2130             if (tempsig)
2131               {
2132                 if (tempsig->timestamp > sigdate)
2133                   {
2134                     if (backsig)
2135                       free_seckey_enc (backsig);
2136
2137                     backsig = tempsig;
2138                     sigdate = backsig->timestamp;
2139                   }
2140                 else
2141                   free_seckey_enc (tempsig);
2142               }
2143           }
2144
2145       seq = 0;
2146
2147       /* It is safe to have this in the unhashed area since the 0x19
2148          is located on the selfsig for convenience, not security. */
2149
2150       while ((p = enum_sig_subpkt (sig->unhashed, SIGSUBPKT_SIGNATURE,
2151                                    &n, &seq, NULL)))
2152         if (n > 3
2153             && ((p[0] == 3 && p[2] == 0x19) || (p[0] == 4 && p[1] == 0x19)))
2154           {
2155             PKT_signature *tempsig = buf_to_sig (p, n);
2156             if (tempsig)
2157               {
2158                 if (tempsig->timestamp > sigdate)
2159                   {
2160                     if (backsig)
2161                       free_seckey_enc (backsig);
2162
2163                     backsig = tempsig;
2164                     sigdate = backsig->timestamp;
2165                   }
2166                 else
2167                   free_seckey_enc (tempsig);
2168               }
2169           }
2170
2171       if (backsig)
2172         {
2173           /* At ths point, backsig contains the most recent 0x19 sig.
2174              Let's see if it is good. */
2175
2176           /* 2==valid, 1==invalid, 0==didn't check */
2177           if (check_backsig (mainpk, subpk, backsig) == 0)
2178             subpk->flags.backsig = 2;
2179           else
2180             subpk->flags.backsig = 1;
2181
2182           free_seckey_enc (backsig);
2183         }
2184     }
2185 }
2186
2187
2188 /*
2189  * Merge information from the self-signatures with the key, so that
2190  * we can later use them more easy.
2191  * The function works by first applying the self signatures to the
2192  * primary key and the to each subkey.
2193  * Here are the rules we use to decide which inormation from which
2194  * self-signature is used:
2195  * We check all self signatures or validity and ignore all invalid signatures.
2196  * All signatures are then ordered by their creation date ....
2197  * For the primary key:
2198  *   FIXME the docs
2199  */
2200 static void
2201 merge_selfsigs (KBNODE keyblock)
2202 {
2203   KBNODE k;
2204   int revoked;
2205   struct revoke_info rinfo;
2206   PKT_public_key *main_pk;
2207   prefitem_t *prefs;
2208   unsigned int mdc_feature;
2209
2210   if (keyblock->pkt->pkttype != PKT_PUBLIC_KEY)
2211     {
2212       if (keyblock->pkt->pkttype == PKT_SECRET_KEY)
2213         {
2214           log_error ("expected public key but found secret key "
2215                      "- must stop\n");
2216           /* We better exit here because a public key is expected at
2217              other places too.  FIXME: Figure this out earlier and
2218              don't get to here at all */
2219           g10_exit (1);
2220         }
2221       BUG ();
2222     }
2223
2224   merge_selfsigs_main (keyblock, &revoked, &rinfo);
2225
2226   /* Now merge in the data from each of the subkeys.  */
2227   for (k = keyblock; k; k = k->next)
2228     {
2229       if (k->pkt->pkttype == PKT_PUBLIC_SUBKEY)
2230         {
2231           merge_selfsigs_subkey (keyblock, k);
2232         }
2233     }
2234
2235   main_pk = keyblock->pkt->pkt.public_key;
2236   if (revoked || main_pk->has_expired || !main_pk->flags.valid)
2237     {
2238       /* If the primary key is revoked, expired, or invalid we
2239        * better set the appropriate flags on that key and all
2240        * subkeys.  */
2241       for (k = keyblock; k; k = k->next)
2242         {
2243           if (k->pkt->pkttype == PKT_PUBLIC_KEY
2244               || k->pkt->pkttype == PKT_PUBLIC_SUBKEY)
2245             {
2246               PKT_public_key *pk = k->pkt->pkt.public_key;
2247               if (!main_pk->flags.valid)
2248                 pk->flags.valid = 0;
2249               if (revoked && !pk->flags.revoked)
2250                 {
2251                   pk->flags.revoked = revoked;
2252                   memcpy (&pk->revoked, &rinfo, sizeof (rinfo));
2253                 }
2254               if (main_pk->has_expired)
2255                 pk->has_expired = main_pk->has_expired;
2256             }
2257         }
2258       return;
2259     }
2260
2261   /* Set the preference list of all keys to those of the primary real
2262    * user ID.  Note: we use these preferences when we don't know by
2263    * which user ID the key has been selected.
2264    * fixme: we should keep atoms of commonly used preferences or
2265    * use reference counting to optimize the preference lists storage.
2266    * FIXME: it might be better to use the intersection of
2267    * all preferences.
2268    * Do a similar thing for the MDC feature flag.  */
2269   prefs = NULL;
2270   mdc_feature = 0;
2271   for (k = keyblock; k && k->pkt->pkttype != PKT_PUBLIC_SUBKEY; k = k->next)
2272     {
2273       if (k->pkt->pkttype == PKT_USER_ID
2274           && !k->pkt->pkt.user_id->attrib_data
2275           && k->pkt->pkt.user_id->is_primary)
2276         {
2277           prefs = k->pkt->pkt.user_id->prefs;
2278           mdc_feature = k->pkt->pkt.user_id->flags.mdc;
2279           break;
2280         }
2281     }
2282   for (k = keyblock; k; k = k->next)
2283     {
2284       if (k->pkt->pkttype == PKT_PUBLIC_KEY
2285           || k->pkt->pkttype == PKT_PUBLIC_SUBKEY)
2286         {
2287           PKT_public_key *pk = k->pkt->pkt.public_key;
2288           if (pk->prefs)
2289             xfree (pk->prefs);
2290           pk->prefs = copy_prefs (prefs);
2291           pk->flags.mdc = mdc_feature;
2292         }
2293     }
2294 }
2295
2296
2297 \f
2298 /* See whether the key fits our requirements and in case we do not
2299  * request the primary key, select a suitable subkey.
2300  *
2301  * Returns: True when a suitable key has been found.
2302  *
2303  * We have to distinguish four cases:  FIXME!
2304  *  1. No usage and no primary key requested
2305  *     Examples for this case are that we have a keyID to be used
2306  *     for decrytion or verification.
2307  *  2. No usage but primary key requested
2308  *     This is the case for all functions which work on an
2309  *     entire keyblock, e.g. for editing or listing
2310  *  3. Usage and primary key requested
2311  *     FXME
2312  *  4. Usage but no primary key requested
2313  *     FIXME
2314  * FIXME: Tell what is going to happen here and something about the rationale
2315  * Note: We don't use this function if no specific usage is requested;
2316  *       This way the getkey functions can be used for plain key listings.
2317  *
2318  * CTX ist the keyblock we are investigating, if FOUNDK is not NULL this
2319  * is the key we actually found by looking at the keyid or a fingerprint and
2320  * may either point to the primary or one of the subkeys.  */
2321 static int
2322 finish_lookup (GETKEY_CTX ctx)
2323 {
2324   KBNODE keyblock = ctx->keyblock;
2325   KBNODE k;
2326   KBNODE foundk = NULL;
2327   PKT_user_id *foundu = NULL;
2328 #define USAGE_MASK  (PUBKEY_USAGE_SIG|PUBKEY_USAGE_ENC|PUBKEY_USAGE_CERT)
2329   unsigned int req_usage = (ctx->req_usage & USAGE_MASK);
2330   /* Request the primary if we're certifying another key, and also
2331      if signing data while --pgp6 or --pgp7 is on since pgp 6 and 7
2332      do not understand signatures made by a signing subkey.  PGP 8
2333      does. */
2334   int req_prim = (ctx->req_usage & PUBKEY_USAGE_CERT) ||
2335     ((PGP6 || PGP7) && (ctx->req_usage & PUBKEY_USAGE_SIG));
2336   u32 latest_date;
2337   KBNODE latest_key;
2338   u32 curtime = make_timestamp ();
2339
2340   assert (keyblock->pkt->pkttype == PKT_PUBLIC_KEY);
2341
2342   ctx->found_key = NULL;
2343
2344   if (ctx->exact)
2345     {
2346       for (k = keyblock; k; k = k->next)
2347         {
2348           if ((k->flag & 1))
2349             {
2350               assert (k->pkt->pkttype == PKT_PUBLIC_KEY
2351                       || k->pkt->pkttype == PKT_PUBLIC_SUBKEY);
2352               foundk = k;
2353               break;
2354             }
2355         }
2356     }
2357
2358   for (k = keyblock; k; k = k->next)
2359     {
2360       if ((k->flag & 2))
2361         {
2362           assert (k->pkt->pkttype == PKT_USER_ID);
2363           foundu = k->pkt->pkt.user_id;
2364           break;
2365         }
2366     }
2367
2368   if (DBG_CACHE)
2369     log_debug ("finish_lookup: checking key %08lX (%s)(req_usage=%x)\n",
2370                (ulong) keyid_from_pk (keyblock->pkt->pkt.public_key, NULL),
2371                foundk ? "one" : "all", req_usage);
2372
2373   if (!req_usage)
2374     {
2375       latest_key = foundk ? foundk : keyblock;
2376       goto found;
2377     }
2378
2379   latest_date = 0;
2380   latest_key = NULL;
2381   /* Do not look at subkeys if a certification key is requested.  */
2382   if ((!foundk || foundk->pkt->pkttype == PKT_PUBLIC_SUBKEY) && !req_prim)
2383     {
2384       KBNODE nextk;
2385       /* Either start a loop or check just this one subkey.  */
2386       for (k = foundk ? foundk : keyblock; k; k = nextk)
2387         {
2388           PKT_public_key *pk;
2389           nextk = k->next;
2390           if (k->pkt->pkttype != PKT_PUBLIC_SUBKEY)
2391             continue;
2392           if (foundk)
2393             nextk = NULL; /* what a hack */
2394           pk = k->pkt->pkt.public_key;
2395           if (DBG_CACHE)
2396             log_debug ("\tchecking subkey %08lX\n",
2397                        (ulong) keyid_from_pk (pk, NULL));
2398           if (!pk->flags.valid)
2399             {
2400               if (DBG_CACHE)
2401                 log_debug ("\tsubkey not valid\n");
2402               continue;
2403             }
2404           if (pk->flags.revoked)
2405             {
2406               if (DBG_CACHE)
2407                 log_debug ("\tsubkey has been revoked\n");
2408               continue;
2409             }
2410           if (pk->has_expired)
2411             {
2412               if (DBG_CACHE)
2413                 log_debug ("\tsubkey has expired\n");
2414               continue;
2415             }
2416           if (pk->timestamp > curtime && !opt.ignore_valid_from)
2417             {
2418               if (DBG_CACHE)
2419                 log_debug ("\tsubkey not yet valid\n");
2420               continue;
2421             }
2422
2423           if (!((pk->pubkey_usage & USAGE_MASK) & req_usage))
2424             {
2425               if (DBG_CACHE)
2426                 log_debug ("\tusage does not match: want=%x have=%x\n",
2427                            req_usage, pk->pubkey_usage);
2428               continue;
2429             }
2430
2431           if (DBG_CACHE)
2432             log_debug ("\tsubkey might be fine\n");
2433           /* In case a key has a timestamp of 0 set, we make sure
2434              that it is used.  A better change would be to compare
2435              ">=" but that might also change the selected keys and
2436              is as such a more intrusive change.  */
2437           if (pk->timestamp > latest_date || (!pk->timestamp && !latest_date))
2438             {
2439               latest_date = pk->timestamp;
2440               latest_key = k;
2441             }
2442         }
2443     }
2444
2445   /* Okay now try the primary key unless we want an exact
2446    * key ID match on a subkey */
2447   if ((!latest_key && !(ctx->exact && foundk != keyblock)) || req_prim)
2448     {
2449       PKT_public_key *pk;
2450       if (DBG_CACHE && !foundk && !req_prim)
2451         log_debug ("\tno suitable subkeys found - trying primary\n");
2452       pk = keyblock->pkt->pkt.public_key;
2453       if (!pk->flags.valid)
2454         {
2455           if (DBG_CACHE)
2456             log_debug ("\tprimary key not valid\n");
2457         }
2458       else if (pk->flags.revoked)
2459         {
2460           if (DBG_CACHE)
2461             log_debug ("\tprimary key has been revoked\n");
2462         }
2463       else if (pk->has_expired)
2464         {
2465           if (DBG_CACHE)
2466             log_debug ("\tprimary key has expired\n");
2467         }
2468       else if (!((pk->pubkey_usage & USAGE_MASK) & req_usage))
2469         {
2470           if (DBG_CACHE)
2471             log_debug ("\tprimary key usage does not match: "
2472                        "want=%x have=%x\n", req_usage, pk->pubkey_usage);
2473         }
2474       else /* Okay.  */
2475         {
2476           if (DBG_CACHE)
2477             log_debug ("\tprimary key may be used\n");
2478           latest_key = keyblock;
2479           latest_date = pk->timestamp;
2480         }
2481     }
2482
2483   if (!latest_key)
2484     {
2485       if (DBG_CACHE)
2486         log_debug ("\tno suitable key found -  giving up\n");
2487       return 0; /* Not found.  */
2488     }
2489
2490 found:
2491   if (DBG_CACHE)
2492     log_debug ("\tusing key %08lX\n",
2493                (ulong) keyid_from_pk (latest_key->pkt->pkt.public_key, NULL));
2494
2495   if (latest_key)
2496     {
2497       PKT_public_key *pk = latest_key->pkt->pkt.public_key;
2498       if (pk->user_id)
2499         free_user_id (pk->user_id);
2500       pk->user_id = scopy_user_id (foundu);
2501     }
2502
2503   ctx->found_key = latest_key;
2504
2505   if (latest_key != keyblock && opt.verbose)
2506     {
2507       char *tempkeystr =
2508         xstrdup (keystr_from_pk (latest_key->pkt->pkt.public_key));
2509       log_info (_("using subkey %s instead of primary key %s\n"),
2510                 tempkeystr, keystr_from_pk (keyblock->pkt->pkt.public_key));
2511       xfree (tempkeystr);
2512     }
2513
2514   cache_user_id (keyblock);
2515
2516   return 1; /* Found.  */
2517 }
2518
2519
2520 /* The main function to lookup a key.  On success the found keyblock
2521    is stored at RET_KEYBLOCK and also in CTX.  If WANT_SECRET is true
2522    a corresponding secret key is required.  */
2523 static int
2524 lookup (getkey_ctx_t ctx, kbnode_t *ret_keyblock, int want_secret)
2525 {
2526   int rc;
2527   int no_suitable_key = 0;
2528
2529   rc = 0;
2530   while (!(rc = keydb_search (ctx->kr_handle, ctx->items, ctx->nitems, NULL)))
2531     {
2532       /* If we are searching for the first key we have to make sure
2533          that the next iteration does not do an implicit reset.
2534          This can be triggered by an empty key ring. */
2535       if (ctx->nitems && ctx->items->mode == KEYDB_SEARCH_MODE_FIRST)
2536         ctx->items->mode = KEYDB_SEARCH_MODE_NEXT;
2537
2538       rc = keydb_get_keyblock (ctx->kr_handle, &ctx->keyblock);
2539       if (rc)
2540         {
2541           log_error ("keydb_get_keyblock failed: %s\n", g10_errstr (rc));
2542           rc = 0;
2543           goto skip;
2544         }
2545
2546       if (want_secret && agent_probe_any_secret_key (NULL, ctx->keyblock))
2547         goto skip; /* No secret key available.  */
2548
2549       /* Warning: node flag bits 0 and 1 should be preserved by
2550        * merge_selfsigs.  For secret keys, premerge did tranfer the
2551        * keys to the keyblock.  */
2552       merge_selfsigs (ctx->keyblock);
2553       if (finish_lookup (ctx))
2554         {
2555           no_suitable_key = 0;
2556           goto found;
2557         }
2558       else
2559         no_suitable_key = 1;
2560
2561     skip:
2562       /* Release resources and continue search. */
2563       release_kbnode (ctx->keyblock);
2564       ctx->keyblock = NULL;
2565     }
2566
2567 found:
2568   if (rc && gpg_err_code (rc) != GPG_ERR_NOT_FOUND)
2569     log_error ("keydb_search failed: %s\n", g10_errstr (rc));
2570
2571   if (!rc)
2572     {
2573       *ret_keyblock = ctx->keyblock; /* Return the keyblock.  */
2574       ctx->keyblock = NULL;
2575     }
2576   else if (gpg_err_code (rc) == GPG_ERR_NOT_FOUND && no_suitable_key)
2577     rc = want_secret? G10ERR_UNU_SECKEY : G10ERR_UNU_PUBKEY;
2578   else if (gpg_err_code (rc) == GPG_ERR_NOT_FOUND)
2579     rc = want_secret? G10ERR_NO_SECKEY : G10ERR_NO_PUBKEY;
2580
2581   release_kbnode (ctx->keyblock);
2582   ctx->keyblock = NULL;
2583
2584   ctx->last_rc = rc;
2585   return rc;
2586 }
2587
2588
2589
2590
2591 /*
2592  * Enumerate certain secret keys.  Caller must use these procedure:
2593  *  1) create a void pointer and initialize it to NULL
2594  *  2) pass this void pointer by reference to this function
2595  *     and provide space for the secret key (pass a buffer for sk)
2596  *  3) call this function as long as it does not return an error.
2597  *     The error code GPG_ERR_EOF indicates the end of the listing.
2598  *  4) Always call this function a last time with SK set to NULL,
2599  *     so that can free it's context.
2600  */
2601 gpg_error_t
2602 enum_secret_keys (void **context, PKT_public_key *sk)
2603 {
2604   gpg_error_t err = 0;
2605   const char *name;
2606   struct
2607   {
2608     int eof;
2609     int state;
2610     strlist_t sl;
2611     kbnode_t keyblock;
2612     kbnode_t node;
2613   } *c = *context;
2614
2615   if (!c)
2616     {
2617       /* Make a new context.  */
2618       c = xtrycalloc (1, sizeof *c);
2619       if (!c)
2620         return gpg_error_from_syserror ();
2621       *context = c;
2622     }
2623
2624   if (!sk)
2625     {
2626       /* Free the context.  */
2627       release_kbnode (c->keyblock);
2628       xfree (c);
2629       *context = NULL;
2630       return 0;
2631     }
2632
2633   if (c->eof)
2634     return gpg_error (GPG_ERR_EOF);
2635
2636   for (;;)
2637     {
2638       /* Loop until we have a keyblock.  */
2639       while (!c->keyblock)
2640         {
2641           /* Loop over the list of secret keys.  */
2642           do
2643             {
2644               name = NULL;
2645               switch (c->state)
2646                 {
2647                 case 0: /* First try to use the --default-key.  */
2648                   if (opt.def_secret_key && *opt.def_secret_key)
2649                     name = opt.def_secret_key;
2650                   c->state = 1;
2651                   break;
2652
2653                 case 1: /* Init list of keys to try.  */
2654                   c->sl = opt.secret_keys_to_try;
2655                   c->state++;
2656                   break;
2657
2658                 case 2: /* Get next item from list.  */
2659                   if (c->sl)
2660                     {
2661                       name = c->sl->d;
2662                       c->sl = c->sl->next;
2663                     }
2664                   else
2665                     c->state++;
2666                   break;
2667
2668                 default: /* No more names to check - stop.  */
2669                   c->eof = 1;
2670                   return gpg_error (GPG_ERR_EOF);
2671                 }
2672             }
2673           while (!name || !*name);
2674
2675           err = getkey_byname (NULL, NULL, name, 1, &c->keyblock);
2676           if (err)
2677             {
2678               /* getkey_byname might return a keyblock even in the
2679                  error case - I have not checked.  Thus better release
2680                  it.  */
2681               release_kbnode (c->keyblock);
2682               c->keyblock = NULL;
2683             }
2684           else
2685             c->node = c->keyblock;
2686         }
2687
2688       /* Get the next key from the current keyblock.  */
2689       for (; c->node; c->node = c->node->next)
2690         {
2691           if (c->node->pkt->pkttype == PKT_PUBLIC_KEY
2692               || c->node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
2693             {
2694               copy_public_key (sk, c->node->pkt->pkt.public_key);
2695               c->node = c->node->next;
2696               return 0; /* Found.  */
2697             }
2698         }
2699
2700       /* Dispose the keyblock and continue.  */
2701       release_kbnode (c->keyblock);
2702       c->keyblock = NULL;
2703     }
2704 }
2705
2706 \f
2707 /*********************************************
2708  ***********  User ID printing helpers *******
2709  *********************************************/
2710
2711 /* Return a string with a printable representation of the user_id.
2712  * this string must be freed by xfree.   */
2713 static char *
2714 get_user_id_string (u32 * keyid)
2715 {
2716   user_id_db_t r;
2717   int pass = 0;
2718   /* Try it two times; second pass reads from key resources.  */
2719   do
2720     {
2721       for (r = user_id_db; r; r = r->next)
2722         {
2723           keyid_list_t a;
2724           for (a = r->keyids; a; a = a->next)
2725             {
2726               if (a->keyid[0] == keyid[0] && a->keyid[1] == keyid[1])
2727                 {
2728                   return xasprintf ("%s %.*s", keystr (keyid), r->len, r->name);
2729                 }
2730             }
2731         }
2732     }
2733   while (++pass < 2 && !get_pubkey (NULL, keyid));
2734   return xasprintf ("%s [?]", keystr (keyid));
2735 }
2736
2737
2738 char *
2739 get_user_id_string_native (u32 * keyid)
2740 {
2741   char *p = get_user_id_string (keyid);
2742   char *p2 = utf8_to_native (p, strlen (p), 0);
2743   xfree (p);
2744   return p2;
2745 }
2746
2747
2748 char *
2749 get_long_user_id_string (u32 * keyid)
2750 {
2751   user_id_db_t r;
2752   keyid_list_t a;
2753   int pass = 0;
2754   /* Try it two times; second pass reads from key resources.  */
2755   do
2756     {
2757       for (r = user_id_db; r; r = r->next)
2758         {
2759           for (a = r->keyids; a; a = a->next)
2760             {
2761               if (a->keyid[0] == keyid[0] && a->keyid[1] == keyid[1])
2762                 {
2763                   return xasprintf ("%08lX%08lX %.*s",
2764                                     (ulong) keyid[0], (ulong) keyid[1],
2765                                     r->len, r->name);
2766                 }
2767             }
2768         }
2769     }
2770   while (++pass < 2 && !get_pubkey (NULL, keyid));
2771   return xasprintf ("%08lX%08lX [?]", (ulong) keyid[0], (ulong) keyid[1]);
2772 }
2773
2774
2775 /* Please try to use get_user_id_native instead of this one.  */
2776 char *
2777 get_user_id (u32 * keyid, size_t * rn)
2778 {
2779   user_id_db_t r;
2780   char *p;
2781   int pass = 0;
2782
2783   /* Try it two times; second pass reads from key resources.  */
2784   do
2785     {
2786       for (r = user_id_db; r; r = r->next)
2787         {
2788           keyid_list_t a;
2789           for (a = r->keyids; a; a = a->next)
2790             {
2791               if (a->keyid[0] == keyid[0] && a->keyid[1] == keyid[1])
2792                 {
2793                   /* An empty string as user id is possible.  Make
2794                      sure that the malloc allocates one byte and does
2795                      not bail out.  */
2796                   p = xmalloc (r->len? r->len : 1);
2797                   memcpy (p, r->name, r->len);
2798                   *rn = r->len;
2799                   return p;
2800                 }
2801             }
2802         }
2803     }
2804   while (++pass < 2 && !get_pubkey (NULL, keyid));
2805   p = xstrdup (user_id_not_found_utf8 ());
2806   *rn = strlen (p);
2807   return p;
2808 }
2809
2810 /* Please try to use get_user_id_byfpr_native instead of this one.  */
2811 char *
2812 get_user_id_native (u32 * keyid)
2813 {
2814   size_t rn;
2815   char *p = get_user_id (keyid, &rn);
2816   char *p2 = utf8_to_native (p, rn, 0);
2817   xfree (p);
2818   return p2;
2819 }
2820
2821
2822 /* Return a user id from the caching by looking it up using the FPR
2823    which mustbe of size MAX_FINGERPRINT_LEN.  */
2824 char *
2825 get_user_id_byfpr (const byte *fpr, size_t *rn)
2826 {
2827   user_id_db_t r;
2828   char *p;
2829   int pass = 0;
2830
2831   /* Try it two times; second pass reads from key resources.  */
2832   do
2833     {
2834       for (r = user_id_db; r; r = r->next)
2835         {
2836           keyid_list_t a;
2837           for (a = r->keyids; a; a = a->next)
2838             {
2839               if (!memcmp (a->fpr, fpr, MAX_FINGERPRINT_LEN))
2840                 {
2841                   /* An empty string as user id is possible.  Make
2842                      sure that the malloc allocates one byte and does
2843                      not bail out.  */
2844                   p = xmalloc (r->len? r->len : 1);
2845                   memcpy (p, r->name, r->len);
2846                   *rn = r->len;
2847                   return p;
2848                 }
2849             }
2850         }
2851     }
2852   while (++pass < 2 && !get_pubkey_byfpr (NULL, fpr));
2853   p = xstrdup (user_id_not_found_utf8 ());
2854   *rn = strlen (p);
2855   return p;
2856 }
2857
2858 char *
2859 get_user_id_byfpr_native (const byte *fpr)
2860 {
2861   size_t rn;
2862   char *p = get_user_id_byfpr (fpr, &rn);
2863   char *p2 = utf8_to_native (p, rn, 0);
2864   xfree (p);
2865   return p2;
2866 }
2867
2868
2869
2870 KEYDB_HANDLE
2871 get_ctx_handle (GETKEY_CTX ctx)
2872 {
2873   return ctx->kr_handle;
2874 }
2875
2876 static void
2877 free_akl (struct akl *akl)
2878 {
2879   if (akl->spec)
2880     free_keyserver_spec (akl->spec);
2881
2882   xfree (akl);
2883 }
2884
2885 void
2886 release_akl (void)
2887 {
2888   while (opt.auto_key_locate)
2889     {
2890       struct akl *akl2 = opt.auto_key_locate;
2891       opt.auto_key_locate = opt.auto_key_locate->next;
2892       free_akl (akl2);
2893     }
2894 }
2895
2896 /* Returns false on error. */
2897 int
2898 parse_auto_key_locate (char *options)
2899 {
2900   char *tok;
2901
2902   while ((tok = optsep (&options)))
2903     {
2904       struct akl *akl, *check, *last = NULL;
2905       int dupe = 0;
2906
2907       if (tok[0] == '\0')
2908         continue;
2909
2910       akl = xmalloc_clear (sizeof (*akl));
2911
2912       if (ascii_strcasecmp (tok, "clear") == 0)
2913         {
2914           xfree (akl);
2915           free_akl (opt.auto_key_locate);
2916           opt.auto_key_locate = NULL;
2917           continue;
2918         }
2919       else if (ascii_strcasecmp (tok, "nodefault") == 0)
2920         akl->type = AKL_NODEFAULT;
2921       else if (ascii_strcasecmp (tok, "local") == 0)
2922         akl->type = AKL_LOCAL;
2923       else if (ascii_strcasecmp (tok, "ldap") == 0)
2924         akl->type = AKL_LDAP;
2925       else if (ascii_strcasecmp (tok, "keyserver") == 0)
2926         akl->type = AKL_KEYSERVER;
2927 #ifdef USE_DNS_CERT
2928       else if (ascii_strcasecmp (tok, "cert") == 0)
2929         akl->type = AKL_CERT;
2930 #endif
2931 #ifdef USE_DNS_PKA
2932       else if (ascii_strcasecmp (tok, "pka") == 0)
2933         akl->type = AKL_PKA;
2934 #endif
2935       else if ((akl->spec = parse_keyserver_uri (tok, 1, NULL, 0)))
2936         akl->type = AKL_SPEC;
2937       else
2938         {
2939           free_akl (akl);
2940           return 0;
2941         }
2942
2943       /* We must maintain the order the user gave us */
2944       for (check = opt.auto_key_locate; check;
2945            last = check, check = check->next)
2946         {
2947           /* Check for duplicates */
2948           if (check->type == akl->type
2949               && (akl->type != AKL_SPEC
2950                   || (akl->type == AKL_SPEC
2951                       && strcmp (check->spec->uri, akl->spec->uri) == 0)))
2952             {
2953               dupe = 1;
2954               free_akl (akl);
2955               break;
2956             }
2957         }
2958
2959       if (!dupe)
2960         {
2961           if (last)
2962             last->next = akl;
2963           else
2964             opt.auto_key_locate = akl;
2965         }
2966     }
2967
2968   return 1;
2969 }
2970
2971
2972 /* Return true if a secret key or secret subkey is available for one
2973    of the public keys in KEYBLOCK.  */
2974 int
2975 have_any_secret_key (ctrl_t ctrl, kbnode_t keyblock)
2976 {
2977   kbnode_t node;
2978
2979   for (node = keyblock; node; node = node->next)
2980     if ((node->pkt->pkttype == PKT_PUBLIC_KEY
2981          || node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
2982         && !agent_probe_secret_key (ctrl, node->pkt->pkt.public_key))
2983       return 1;
2984   return 0;
2985 }
2986
2987
2988 /* Return true if a secret key is available for the public key with
2989  * the given KEYID.  This is just a fast check and does not tell us
2990  * whether the secret key is valid.  It merely tells os whether there
2991  * is some secret key.  */
2992 int
2993 have_secret_key_with_kid (u32 *keyid)
2994 {
2995   gpg_error_t err;
2996   KEYDB_HANDLE kdbhd;
2997   KEYDB_SEARCH_DESC desc;
2998   kbnode_t keyblock;
2999   kbnode_t node;
3000   int result = 0;
3001
3002   kdbhd = keydb_new ();
3003   memset (&desc, 0, sizeof desc);
3004   desc.mode = KEYDB_SEARCH_MODE_LONG_KID;
3005   desc.u.kid[0] = keyid[0];
3006   desc.u.kid[1] = keyid[1];
3007   while (!result && !(err = keydb_search (kdbhd, &desc, 1, NULL)))
3008     {
3009       err = keydb_get_keyblock (kdbhd, &keyblock);
3010       if (err)
3011         {
3012           log_error (_("error reading keyblock: %s\n"), g10_errstr (err));
3013           break;
3014         }
3015
3016       for (node = keyblock; node; node = node->next)
3017         {
3018           /* Bit 0 of the flags is set if the search found the key
3019              using that key or subkey.  */
3020           if ((node->flag & 1))
3021             {
3022               assert (node->pkt->pkttype == PKT_PUBLIC_KEY
3023                       || node->pkt->pkttype == PKT_PUBLIC_SUBKEY);
3024
3025               if (!agent_probe_secret_key (NULL, node->pkt->pkt.public_key))
3026                 {
3027                   result = 1;
3028                   break;
3029                 }
3030             }
3031         }
3032       release_kbnode (keyblock);
3033     }
3034   keydb_release (kdbhd);
3035   return result;
3036 }