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