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