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