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