See ChangeLog: Thu Dec 10 20:15:36 CET 1998 Werner Koch
[gnupg.git] / g10 / getkey.c
1 /* getkey.c -  Get a key from the database
2  *      Copyright (C) 1998 Free Software Foundation, Inc.
3  *
4  * This file is part of GNUPG.
5  *
6  * GNUPG is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * GNUPG is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19  */
20
21 #define DEFINES_GETKEY_CTX 1
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 "i18n.h"
37
38 #define MAX_UNK_CACHE_ENTRIES 1000   /* we use a linked list - so I guess
39                                       * this is a reasonable limit */
40 #define MAX_PK_CACHE_ENTRIES    50
41 #define MAX_UID_CACHE_ENTRIES   50
42
43
44 struct getkey_ctx_s {
45     int mode;
46     int internal;
47     u32 keyid[2];
48     char *namebuf;
49     const char *name;
50     int primary;
51     KBNODE keyblock;
52     KBPOS kbpos;
53     int last_rc;
54     ulong count;
55 };
56
57
58
59
60
61
62 static struct {
63     int any;
64     int okay_count;
65     int nokey_count;
66     int error_count;
67 } lkup_stats[21];
68
69
70
71
72 #if MAX_UNK_CACHE_ENTRIES
73   typedef struct keyid_list {
74       struct keyid_list *next;
75       u32 keyid[2];
76   } *keyid_list_t;
77   static keyid_list_t unknown_keyids;
78   static int unk_cache_entries;   /* number of entries in unknown keys cache */
79   static int unk_cache_disabled;
80 #endif
81
82 #if MAX_PK_CACHE_ENTRIES
83   typedef struct pk_cache_entry {
84       struct pk_cache_entry *next;
85       u32 keyid[2];
86       PKT_public_key *pk;
87   } *pk_cache_entry_t;
88   static pk_cache_entry_t pk_cache;
89   static int pk_cache_entries;   /* number of entries in pk cache */
90   static int pk_cache_disabled;
91 #endif
92
93 #if MAX_UID_CACHE_ENTRIES < 5
94     #error we really need the userid cache
95 #endif
96 typedef struct user_id_db {
97     struct user_id_db *next;
98     u32 keyid[2];
99     int len;
100     char name[1];
101 } *user_id_db_t;
102 static user_id_db_t user_id_db;
103 static int uid_cache_entries;   /* number of entries in uid cache */
104
105
106
107 static int lookup( GETKEY_CTX *ctx, PKT_public_key *pk,
108                    int mode,  u32 *keyid, const char *name,
109                    KBNODE *ret_keyblock, int primary  );
110 static void lookup_close( GETKEY_CTX ctx );
111 static int  lookup_read( GETKEY_CTX ctx,
112                          PKT_public_key *pk, KBNODE *ret_keyblock );
113 static int lookup_sk( PKT_secret_key *sk,
114                    int mode,  u32 *keyid, const char *name, int primary );
115
116
117
118 static void
119 print_stats()
120 {
121     int i;
122     for(i=0; i < DIM(lkup_stats); i++ ) {
123         if( lkup_stats[i].any )
124             fprintf(stderr,
125                     "lookup stats: mode=%-2d  ok=%-6d  nokey=%-6d  err=%-6d\n",
126                     i,
127                     lkup_stats[i].okay_count,
128                     lkup_stats[i].nokey_count,
129                     lkup_stats[i].error_count );
130     }
131 }
132
133
134
135 static void
136 cache_public_key( PKT_public_key *pk )
137 {
138   #if MAX_PK_CACHE_ENTRIES
139     pk_cache_entry_t ce;
140     u32 keyid[2];
141
142     if( pk_cache_disabled )
143         return;
144
145     if( is_ELGAMAL(pk->pubkey_algo)
146         || pk->pubkey_algo == PUBKEY_ALGO_DSA
147         || is_RSA(pk->pubkey_algo) ) {
148         keyid_from_pk( pk, keyid );
149     }
150     else
151         return; /* don't know how to get the keyid */
152
153     for( ce = pk_cache; ce; ce = ce->next )
154         if( ce->keyid[0] == keyid[0] && ce->keyid[1] == keyid[1] ) {
155             if( DBG_CACHE )
156                 log_debug("cache_public_key: already in cache\n");
157             return;
158         }
159
160     if( pk_cache_entries >= MAX_PK_CACHE_ENTRIES ) {
161         /* fixme: use another algorithm to free some cache slots */
162         pk_cache_disabled=1;
163         if( opt.verbose )
164             log_info(_("too many entries in pk cache - disabled\n"));
165         return;
166     }
167     pk_cache_entries++;
168     ce = m_alloc( sizeof *ce );
169     ce->next = pk_cache;
170     pk_cache = ce;
171     ce->pk = copy_public_key( NULL, pk );
172     ce->keyid[0] = keyid[0];
173     ce->keyid[1] = keyid[1];
174   #endif
175 }
176
177
178 /****************
179  * Store the association of keyid and userid
180  */
181 void
182 cache_user_id( PKT_user_id *uid, u32 *keyid )
183 {
184     user_id_db_t r;
185
186     for(r=user_id_db; r; r = r->next )
187         if( r->keyid[0] == keyid[0] && r->keyid[1] == keyid[1] ) {
188             if( DBG_CACHE )
189                log_debug("cache_user_id: already in cache\n");
190             return;
191         }
192
193     if( uid_cache_entries >= MAX_UID_CACHE_ENTRIES ) {
194         /* fixme: use another algorithm to free some cache slots */
195         r = user_id_db;
196         user_id_db = r->next;
197         m_free(r);
198         uid_cache_entries--;
199     }
200     r = m_alloc( sizeof *r + uid->len-1 );
201     r->keyid[0] = keyid[0];
202     r->keyid[1] = keyid[1];
203     r->len = uid->len;
204     memcpy(r->name, uid->name, r->len);
205     r->next = user_id_db;
206     user_id_db = r;
207     uid_cache_entries++;
208 }
209
210
211
212 /****************
213  * Get a public key and store it into the allocated pk
214  * can be called with PK set to NULL to just read it into some
215  * internal structures.
216  */
217 int
218 get_pubkey( PKT_public_key *pk, u32 *keyid )
219 {
220     int internal = 0;
221     int rc = 0;
222
223   #if MAX_UNK_CACHE_ENTRIES
224     {   /* let's see whether we checked the keyid already */
225         keyid_list_t kl;
226         for( kl = unknown_keyids; kl; kl = kl->next )
227             if( kl->keyid[0] == keyid[0] && kl->keyid[1] == keyid[1] )
228                 return G10ERR_NO_PUBKEY; /* already checked and not found */
229     }
230   #endif
231
232   #if MAX_PK_CACHE_ENTRIES
233     {   /* Try to get it from the cache */
234         pk_cache_entry_t ce;
235         for( ce = pk_cache; ce; ce = ce->next ) {
236             if( ce->keyid[0] == keyid[0] && ce->keyid[1] == keyid[1] ) {
237                 if( pk )
238                     copy_public_key( pk, ce->pk );
239                 return 0;
240             }
241         }
242     }
243   #endif
244     /* more init stuff */
245     if( !pk ) {
246         pk = m_alloc_clear( sizeof *pk );
247         internal++;
248     }
249
250
251     /* do a lookup */
252     rc = lookup( NULL, pk, 11, keyid, NULL, NULL, 0 );
253     if( !rc )
254         goto leave;
255
256   #if MAX_UNK_CACHE_ENTRIES
257     /* not found: store it for future reference */
258     if( unk_cache_disabled )
259         ;
260     else if( ++unk_cache_entries > MAX_UNK_CACHE_ENTRIES ) {
261         unk_cache_disabled = 1;
262         if( opt.verbose )
263             log_info(_("too many entries in unk cache - disabled\n"));
264     }
265     else {
266         keyid_list_t kl;
267
268         kl = m_alloc( sizeof *kl );
269         kl->keyid[0] = keyid[0];
270         kl->keyid[1] = keyid[1];
271         kl->next = unknown_keyids;
272         unknown_keyids = kl;
273     }
274   #endif
275     rc = G10ERR_NO_PUBKEY;
276
277   leave:
278     if( !rc )
279         cache_public_key( pk );
280     if( internal )
281         free_public_key(pk);
282     return rc;
283 }
284
285
286 static int
287 hextobyte( const byte *s )
288 {
289     int c;
290
291     if( *s >= '0' && *s <= '9' )
292         c = 16 * (*s - '0');
293     else if( *s >= 'A' && *s <= 'F' )
294         c = 16 * (10 + *s - 'A');
295     else if( *s >= 'a' && *s <= 'f' )
296         c = 16 * (10 + *s - 'a');
297     else
298         return -1;
299     s++;
300     if( *s >= '0' && *s <= '9' )
301         c += *s - '0';
302     else if( *s >= 'A' && *s <= 'F' )
303         c += 10 + *s - 'A';
304     else if( *s >= 'a' && *s <= 'f' )
305         c += 10 + *s - 'a';
306     else
307         return -1;
308     return c;
309 }
310
311
312
313 /****************
314  * Return the type of the user id:
315  *
316  *  0 = Invalid user ID
317  *  1 = exact match
318  *  2 = match a substring
319  *  3 = match an email address
320  *  4 = match a substring of an email address
321  *  5 = match an email address, but compare from end
322  * 10 = it is a short KEYID (don't care about keyid[0])
323  * 11 = it is a long  KEYID
324  * 16 = it is a 16 byte fingerprint
325  * 20 = it is a 20 byte fingerprint
326  *
327  * if fprint is not NULL, it should be an array of at least 20 bytes.
328  *
329  * Rules used:
330  * - If the username starts with 8,9,16 or 17 hex-digits (the first one
331  *   must be in the range 0..9), this is considered a keyid; depending
332  *   on the length a short or complete one.
333  * - If the username starts with 32,33,40 or 41 hex-digits (the first one
334  *   must be in the range 0..9), this is considered a fingerprint.
335  * - If the username starts with a left angle, we assume it is a complete
336  *   email address and look only at this part.
337  * - If the username starts with a '.', we assume it is the ending
338  *   part of an email address
339  * - If the username starts with an '@', we assume it is a part of an
340  *   email address
341  * - If the userid start with an '=' an exact compare is done.
342  * - If the userid starts with a '*' a case insensitive substring search is
343  *   done (This is the default).
344  */
345
346 int
347 classify_user_id( const char *name, u32 *keyid, byte *fprint,
348                   const char **retstr, size_t *retlen )
349 {
350     const char *s;
351     int mode = 0;
352
353     /* check what kind of name it is */
354     for(s = name; *s && isspace(*s); s++ )
355         ;
356     if( isdigit( *s ) ) { /* a keyid or a fingerprint */
357         int i, j;
358         char buf[9];
359
360         if( *s == '0' && s[1] == 'x' && isxdigit(s[2]) )
361             s += 2; /*kludge to allow 0x034343434 */
362         for(i=0; isxdigit(s[i]); i++ )
363             ;
364         if( s[i] && !isspace(s[i]) ) /* not terminated by EOS or blank*/
365             return 0;
366         else if( i == 8 || (i == 9 && *s == '0') ) { /* short keyid */
367             if( i==9 )
368                 s++;
369             if( keyid ) {
370                 keyid[0] = 0;
371                 keyid[1] = strtoul( s, NULL, 16 );
372             }
373             mode = 10;
374         }
375         else if( i == 16 || (i == 17 && *s == '0') ) { /* complete keyid */
376             if( i==17 )
377                 s++;
378             mem2str(buf, s, 9 );
379             keyid[0] = strtoul( buf, NULL, 16 );
380             keyid[1] = strtoul( s+8, NULL, 16 );
381             mode = 11;
382         }
383         else if( i == 32 || ( i == 33 && *s == '0' ) ) { /* md5 fingerprint */
384             if( i==33 )
385                 s++;
386             if( fprint ) {
387                 memset(fprint+16, 4, 0);
388                 for(j=0; j < 16; j++, s+=2 ) {
389                     int c = hextobyte( s );
390                     if( c == -1 )
391                         return 0;
392                     fprint[j] = c;
393                 }
394             }
395             mode = 16;
396         }
397         else if( i == 40 || ( i == 41 && *s == '0' ) ) { /* sha1/rmd160 fprint*/
398             if( i==33 )
399                 s++;
400             if( fprint ) {
401                 for(j=0; j < 20; j++, s+=2 ) {
402                     int c = hextobyte( s );
403                     if( c == -1 )
404                         return 0;
405                     fprint[j] = c;
406                 }
407             }
408             mode = 20;
409         }
410         else
411             return 0;
412     }
413     else if( *s == '=' ) { /* exact search */
414         mode = 1;
415         s++;
416     }
417     else if( *s == '*' ) { /* substring search */
418         mode = 2;
419         s++;
420     }
421     else if( *s == '<' ) { /* an email address */
422         mode = 3;
423     }
424     else if( *s == '@' ) { /* a part of an email address */
425         mode = 4;
426         s++;
427     }
428     else if( *s == '.' ) { /* an email address, compare from end */
429         mode = 5;
430         s++;
431     }
432     else if( *s == '#' ) { /* use local id */
433         return 0;
434     }
435     else if( !*s )  /* empty string */
436         return 0;
437     else
438         mode = 2;
439
440     if( retstr )
441         *retstr = s;
442     if( retlen )
443         *retlen = strlen(s);
444
445     return mode;
446 }
447
448
449
450 /****************
451  * Try to get the pubkey by the userid. This function looks for the
452  * first pubkey certificate which has the given name in a user_id.
453  * if pk has the pubkey algo set, the function will only return
454  * a pubkey with that algo.
455  */
456
457 static int
458 key_byname( int secret, GETKEY_CTX *retctx,
459             PKT_public_key *pk, PKT_secret_key *sk,
460             const char *name, KBNODE *ret_kb )
461 {
462     int internal = 0;
463     int rc = 0;
464     const char *s;
465     u32 keyid[2] = {0}; /* init to avoid compiler warning */
466     byte fprint[20];
467     int mode;
468
469     mode = classify_user_id( name, keyid, fprint, &s, NULL );
470     if( !mode ) {
471         rc = G10ERR_INV_USER_ID;
472         goto leave;
473     }
474
475     if( secret ) {
476         if( !sk ) {
477             sk = m_alloc_clear( sizeof *sk );
478             internal++;
479         }
480         rc = mode < 16? lookup_sk( sk, mode, keyid, s, 1 )
481                       : lookup_sk( sk, mode, keyid, fprint, 1 );
482     }
483     else {
484         if( !pk ) {
485             pk = m_alloc_clear( sizeof *pk );
486             internal++;
487         }
488         rc = mode < 16? lookup( retctx, pk, mode, keyid, s, ret_kb, 1 )
489                       : lookup( retctx, pk, mode, keyid, fprint, ret_kb, 1 );
490     }
491
492
493   leave:
494     if( internal && secret )
495         m_free( sk );
496     else if( internal )
497         m_free( pk );
498     return rc;
499 }
500
501 int
502 get_pubkey_byname( GETKEY_CTX *retctx, PKT_public_key *pk,
503                    const char *name, KBNODE *ret_keyblock )
504 {
505     int rc;
506
507     if( !pk ) {
508         /* fixme: key_byname should not need a pk in this case */
509         pk = m_alloc_clear( sizeof *pk );
510         rc = key_byname( 0, retctx, pk, NULL, name, ret_keyblock );
511         free_public_key( pk );
512     }
513     else
514         rc = key_byname( 0, retctx, pk, NULL, name, ret_keyblock );
515     return rc;
516 }
517
518 int
519 get_pubkey_next( GETKEY_CTX ctx, PKT_public_key *pk, KBNODE *ret_keyblock )
520 {
521     int rc;
522
523     if( !pk ) {
524         /* fixme: lookup_read should not need a pk in this case */
525         pk = m_alloc_clear( sizeof *pk );
526         rc = lookup_read( ctx, pk, ret_keyblock );
527         free_public_key( pk );
528     }
529     else
530         rc = lookup_read( ctx, pk, ret_keyblock );
531     return rc;
532 }
533
534 void
535 get_pubkey_end( GETKEY_CTX ctx )
536 {
537     if( ctx ) {
538         lookup_close( ctx );
539         m_free( ctx );
540     }
541 }
542
543 /****************
544  * Search for a key with the given fingerprint.
545  */
546 int
547 get_pubkey_byfprint( PKT_public_key *pk, const byte *fprint, size_t fprint_len)
548 {
549     int rc;
550
551     if( fprint_len == 20 || fprint_len == 16 )
552         rc = lookup( NULL, pk, fprint_len, NULL, fprint, NULL, 0 );
553     else
554         rc = G10ERR_GENERAL; /* Oops */
555     return rc;
556 }
557
558 /****************
559  * Search for a key with the given fingerprint and return the
560  * complete keyblock which may have more than only this key.
561  */
562 int
563 get_keyblock_byfprint( KBNODE *ret_keyblock, const byte *fprint,
564                                                 size_t fprint_len )
565 {
566     int rc;
567     PKT_public_key *pk = m_alloc_clear( sizeof *pk );
568
569     if( fprint_len == 20 || fprint_len == 16 )
570         rc = lookup( NULL, pk, fprint_len, NULL, fprint, ret_keyblock, 0 );
571     else
572         rc = G10ERR_GENERAL; /* Oops */
573
574     free_public_key( pk );
575     return rc;
576 }
577
578 /****************
579  * Get a secret key and store it into sk
580  */
581 int
582 get_seckey( PKT_secret_key *sk, u32 *keyid )
583 {
584     int rc;
585
586     rc = lookup_sk( sk, 11, keyid, NULL, 0 );
587     if( !rc ) {
588         /* check the secret key (this may prompt for a passprase to
589          * unlock the secret key
590          */
591         rc = check_secret_key( sk, 0 );
592     }
593
594     return rc;
595 }
596
597 /****************
598  * Check whether the secret key is available
599  * Returns: 0 := key is available
600  *          G10ERR_NO_SECKEY := not availabe
601  */
602 int
603 seckey_available( u32 *keyid )
604 {
605     PKT_secret_key *sk;
606     int rc;
607
608     sk = m_alloc_clear( sizeof *sk );
609     rc = lookup_sk( sk, 11, keyid, NULL, 0 );
610     free_secret_key( sk );
611     return rc;
612 }
613
614
615
616 /****************
617  * Get a secret key by name and store it into sk
618  * If NAME is NULL use the default key
619  */
620 int
621 get_seckey_byname( PKT_secret_key *sk, const char *name, int unprotect )
622 {
623     int rc;
624
625     if( !name && opt.def_secret_key && *opt.def_secret_key )
626         rc = key_byname( 1, NULL, NULL, sk, opt.def_secret_key, NULL );
627     else if( !name ) /* use the first one as default key */
628         rc = lookup_sk( sk, 15, NULL, NULL, 1 );
629     else
630         rc = key_byname( 1, NULL, NULL, sk, name, NULL );
631     if( !rc && unprotect )
632         rc = check_secret_key( sk, 0 );
633
634     return rc;
635 }
636
637
638 static int
639 compare_name( const char *uid, size_t uidlen, const char *name, int mode )
640 {
641     int i;
642     const char *s, *se;
643
644     if( mode == 1 ) {  /* exact match */
645         for(i=0; name[i] && uidlen; i++, uidlen-- )
646             if( uid[i] != name[i] )
647                 break;
648         if( !uidlen && !name[i] )
649             return 0; /* found */
650     }
651     else if( mode == 2 ) { /* case insensitive substring */
652         if( memistr( uid, uidlen, name ) )
653             return 0;
654     }
655     else if( mode >= 3 && mode <= 5 ) { /* look at the email address */
656         for( i=0, s= uid; i < uidlen && *s != '<'; s++, i++ )
657             ;
658         if( i < uidlen )  {
659             /* skip opening delim and one char and look for the closing one*/
660             s++; i++;
661             for( se=s+1, i++; i < uidlen && *se != '>'; se++, i++ )
662                 ;
663             if( i < uidlen ) {
664                 i = se - s;
665                 if( mode == 3 ) { /* exact email address */
666                     if( strlen(name)-2 == i && !memicmp( s, name+1, i) )
667                         return 0;
668                 }
669                 else if( mode == 4 ) {  /* email substring */
670                     if( memistr( s, i, name ) )
671                         return 0;
672                 }
673                 else { /* email from end */
674                     /* nyi */
675                 }
676             }
677         }
678     }
679     else
680         BUG();
681
682     return -1; /* not found */
683 }
684
685
686
687 /****************
688  * Assume that knode points to a public key packet  and keyblock is
689  * the entire keyblock.  This function adds all relevant information from
690  * a selfsignature to the public key.
691  */
692
693 static void
694 merge_one_pk_and_selfsig( KBNODE keyblock, KBNODE knode )
695 {
696     PKT_public_key *pk = knode->pkt->pkt.public_key;
697     PKT_signature *sig;
698     KBNODE k;
699     u32 kid[2];
700     u32 sigdate = 0;
701
702     assert(    knode->pkt->pkttype == PKT_PUBLIC_KEY
703             || knode->pkt->pkttype == PKT_PUBLIC_SUBKEY );
704
705     if( pk->version < 4 )
706         return; /* this is only needed for version >=4 packets */
707
708     /* find the selfsignature */
709     if( knode->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
710         k = find_kbnode( keyblock, PKT_PUBLIC_KEY );
711         if( !k )
712            BUG(); /* keyblock without primary key!!! */
713         keyid_from_pk( knode->pkt->pkt.public_key, kid );
714     }
715     else
716         keyid_from_pk( pk, kid );
717
718     for(k=keyblock; k; k = k->next ) {
719         if( k->pkt->pkttype == PKT_SIGNATURE
720             && (sig=k->pkt->pkt.signature)->sig_class >= 0x10
721             && sig->sig_class <= 0x30
722             && sig->keyid[0] == kid[0]
723             && sig->keyid[1] == kid[1]
724             && sig->version > 3 ) {
725             /* okay this is a self-signature which can be used.
726              * We use the latest self-signature.
727              * FIXME: We should only use this if the signature is valid
728              *        but this is time consuming - we must provide another
729              *        way to handle this
730              */
731             const byte *p;
732             u32 ed;
733
734             p = parse_sig_subpkt( sig->hashed_data, SIGSUBPKT_KEY_EXPIRE, NULL );
735             ed = p? pk->timestamp + buffer_to_u32(p):0;
736             if( sig->timestamp > sigdate ) {
737                 pk->expiredate = ed;
738                 sigdate = sig->timestamp;
739             }
740             /* fixme: add usage etc. to pk */
741         }
742     }
743 }
744
745
746 /****************
747  * merge all selfsignatures with the keys.
748  */
749 void
750 merge_keys_and_selfsig( KBNODE keyblock )
751 {
752     PKT_public_key *pk = NULL;
753     PKT_secret_key *sk = NULL;
754     PKT_signature *sig;
755     KBNODE k;
756     u32 kid[2] = { 0, 0 };
757     u32 sigdate = 0;
758
759     for(k=keyblock; k; k = k->next ) {
760         if( k->pkt->pkttype == PKT_PUBLIC_KEY
761             || k->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
762             pk = k->pkt->pkt.public_key; sk = NULL;
763             if( pk->version < 4 )
764                 pk = NULL; /* not needed for old keys */
765             else if( k->pkt->pkttype == PKT_PUBLIC_KEY )
766                 keyid_from_pk( pk, kid );
767         }
768         else if( k->pkt->pkttype == PKT_SECRET_KEY
769             || k->pkt->pkttype == PKT_SECRET_SUBKEY ) {
770             pk = NULL; sk = k->pkt->pkt.secret_key;
771             if( sk->version < 4 )
772                 sk = NULL;
773             else if( k->pkt->pkttype == PKT_SECRET_KEY )
774                 keyid_from_sk( sk, kid );
775         }
776         else if( (pk || sk ) && k->pkt->pkttype == PKT_SIGNATURE
777                  && (sig=k->pkt->pkt.signature)->sig_class >= 0x10
778                  && sig->sig_class <= 0x30 && sig->version > 3
779                  && sig->keyid[0] == kid[0] && sig->keyid[1] == kid[1] ) {
780             /* okay this is a self-signature which can be used.
781              * FIXME: We should only use this if the signature is valid
782              *        but this is time consuming - we must provide another
783              *        way to handle this
784              */
785             const byte *p;
786             u32 ed;
787
788             p = parse_sig_subpkt( sig->hashed_data, SIGSUBPKT_KEY_EXPIRE, NULL );
789             if( pk ) {
790                 ed = p? pk->timestamp + buffer_to_u32(p):0;
791                 if( sig->timestamp > sigdate ) {
792                     pk->expiredate = ed;
793                     sigdate = sig->timestamp;
794                 }
795             }
796             else {
797                 ed = p? sk->timestamp + buffer_to_u32(p):0;
798                 if( sig->timestamp > sigdate ) {
799                     sk->expiredate = ed;
800                     sigdate = sig->timestamp;
801                 }
802             }
803         }
804     }
805 }
806
807
808 static KBNODE
809 find_by_name( KBNODE keyblock, PKT_public_key *pk, const char *name,
810               int mode, byte *namehash, int *use_namehash )
811 {
812     KBNODE k, kk;
813
814     for(k=keyblock; k; k = k->next ) {
815         if( k->pkt->pkttype == PKT_USER_ID
816             && !compare_name( k->pkt->pkt.user_id->name,
817                               k->pkt->pkt.user_id->len, name, mode)) {
818             /* we found a matching name, look for the key */
819             for(kk=keyblock; kk; kk = kk->next ) {
820                 if( (    kk->pkt->pkttype == PKT_PUBLIC_KEY
821                       || kk->pkt->pkttype == PKT_PUBLIC_SUBKEY )
822                     && ( !pk->pubkey_algo
823                          || pk->pubkey_algo
824                             == kk->pkt->pkt.public_key->pubkey_algo)
825                     && ( !pk->pubkey_usage
826                          || !check_pubkey_algo2(
827                                kk->pkt->pkt.public_key->pubkey_algo,
828                                                    pk->pubkey_usage ))
829                   )
830                     break;
831             }
832             if( kk ) {
833                 u32 aki[2];
834                 keyid_from_pk( kk->pkt->pkt.public_key, aki );
835                 cache_user_id( k->pkt->pkt.user_id, aki );
836                 rmd160_hash_buffer( namehash,
837                                     k->pkt->pkt.user_id->name,
838                                     k->pkt->pkt.user_id->len );
839                 *use_namehash = 1;
840                 return kk;
841             }
842             else if( is_RSA(pk->pubkey_algo) )
843                 log_error("RSA key cannot be used in this version\n");
844             else
845                 log_error("No key for userid\n");
846         }
847     }
848     return NULL;
849 }
850
851
852 static KBNODE
853 find_by_keyid( KBNODE keyblock, PKT_public_key *pk, u32 *keyid, int mode )
854 {
855     KBNODE k;
856
857     if( DBG_CACHE )
858         log_debug("lookup keyid=%08lx%08lx req_algo=%d mode=%d\n",
859                    (ulong)keyid[0], (ulong)keyid[1], pk->pubkey_algo, mode );
860
861     for(k=keyblock; k; k = k->next ) {
862         if(    k->pkt->pkttype == PKT_PUBLIC_KEY
863             || k->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
864             u32 aki[2];
865             keyid_from_pk( k->pkt->pkt.public_key, aki );
866             if( DBG_CACHE )
867                 log_debug("         aki=%08lx%08lx algo=%d\n",
868                                 (ulong)aki[0], (ulong)aki[1],
869                                  k->pkt->pkt.public_key->pubkey_algo    );
870
871             if( aki[1] == keyid[1]
872                 && ( mode == 10 || aki[0] == keyid[0] )
873                 && ( !pk->pubkey_algo
874                      || pk->pubkey_algo
875                         == k->pkt->pkt.public_key->pubkey_algo) ){
876                 KBNODE kk;
877                 /* cache the userid */
878                 for(kk=keyblock; kk; kk = kk->next )
879                     if( kk->pkt->pkttype == PKT_USER_ID )
880                         break;
881                 if( kk )
882                     cache_user_id( kk->pkt->pkt.user_id, aki );
883                 else
884                     log_error("No userid for key\n");
885                 return k; /* found */
886             }
887         }
888     }
889     return NULL;
890 }
891
892
893 static KBNODE
894 find_first( KBNODE keyblock, PKT_public_key *pk )
895 {
896     KBNODE k;
897
898     for(k=keyblock; k; k = k->next ) {
899         if(    k->pkt->pkttype == PKT_PUBLIC_KEY
900             || k->pkt->pkttype == PKT_PUBLIC_SUBKEY )
901         {
902             if( !pk->pubkey_algo
903                 || pk->pubkey_algo == k->pkt->pkt.public_key->pubkey_algo )
904                 return k;
905         }
906     }
907     return NULL;
908 }
909
910
911 static KBNODE
912 find_by_fpr( KBNODE keyblock, PKT_public_key *pk, const char *name, int mode )
913 {
914     KBNODE k;
915
916     for(k=keyblock; k; k = k->next ) {
917         if(    k->pkt->pkttype == PKT_PUBLIC_KEY
918             || k->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
919             byte afp[MAX_FINGERPRINT_LEN];
920             size_t an;
921
922             fingerprint_from_pk(k->pkt->pkt.public_key, afp, &an );
923
924             if( DBG_CACHE ) {
925                 u32 aki[2];
926                 keyid_from_pk( k->pkt->pkt.public_key, aki );
927                 log_debug("         aki=%08lx%08lx algo=%d mode=%d an=%u\n",
928                                 (ulong)aki[0], (ulong)aki[1],
929                         k->pkt->pkt.public_key->pubkey_algo, mode, an );
930             }
931
932             if( an == mode
933                 && !memcmp( afp, name, an)
934                 && ( !pk->pubkey_algo
935                      || pk->pubkey_algo == k->pkt->pkt.public_key->pubkey_algo) )
936                 return k;
937         }
938     }
939     return NULL;
940 }
941
942
943 static void
944 finish_lookup( KBNODE keyblock, PKT_public_key *pk, KBNODE k, byte *namehash,
945                                                int use_namehash, int primary )
946 {
947     assert(    k->pkt->pkttype == PKT_PUBLIC_KEY
948             || k->pkt->pkttype == PKT_PUBLIC_SUBKEY );
949     assert( keyblock->pkt->pkttype == PKT_PUBLIC_KEY );
950     if( primary && !pk->pubkey_usage ) {
951         copy_public_key_new_namehash( pk, keyblock->pkt->pkt.public_key,
952                                       use_namehash? namehash:NULL);
953         merge_one_pk_and_selfsig( keyblock, keyblock );
954     }
955     else {
956         if( primary && pk->pubkey_usage
957             && check_pubkey_algo2( k->pkt->pkt.public_key->pubkey_algo,
958                        pk->pubkey_usage ) == G10ERR_WR_PUBKEY_ALGO ) {
959             /* if the usage is not correct, try to use a subkey */
960             KBNODE save_k = k;
961
962             k = NULL;
963             /* kludge for pgp 5: which doesn't accept type 20:
964              * try to use a type 16 subkey instead */
965             if( pk->pubkey_usage == PUBKEY_USAGE_ENC ) {
966                 for( k = save_k; k; k = k->next ) {
967                     if( k->pkt->pkttype == PKT_PUBLIC_SUBKEY
968                         && k->pkt->pkt.public_key->pubkey_algo
969                             == PUBKEY_ALGO_ELGAMAL_E
970                         && !check_pubkey_algo2(
971                                 k->pkt->pkt.public_key->pubkey_algo,
972                                                  pk->pubkey_usage ) )
973                         break;
974                 }
975             }
976
977             if( !k ) {
978                 for(k = save_k ; k; k = k->next ) {
979                     if( k->pkt->pkttype == PKT_PUBLIC_SUBKEY
980                         && !check_pubkey_algo2(
981                                 k->pkt->pkt.public_key->pubkey_algo,
982                                                  pk->pubkey_usage ) )
983                         break;
984                 }
985             }
986             if( !k )
987                 k = save_k;
988             else
989                 log_info(_("using secondary key %08lX "
990                            "instead of primary key %08lX\n"),
991                       (ulong)keyid_from_pk( k->pkt->pkt.public_key, NULL),
992                       (ulong)keyid_from_pk( save_k->pkt->pkt.public_key, NULL)
993                         );
994         }
995
996         copy_public_key_new_namehash( pk, k->pkt->pkt.public_key,
997                                       use_namehash? namehash:NULL);
998         merge_one_pk_and_selfsig( keyblock, k );
999     }
1000 }
1001
1002 /****************
1003  * Lookup a key by scanning all keyresources
1004  *   mode 1 = lookup by NAME (exact)
1005  *        2 = lookup by NAME (substring)
1006  *        3 = lookup by NAME (email address)
1007  *        4 = email address (substring)
1008  *        5 = email address (compare from end)
1009  *       10 = lookup by short KEYID (don't care about keyid[0])
1010  *       11 = lookup by long  KEYID
1011  *       15 = Get the first key.
1012  *       16 = lookup by 16 byte fingerprint which is stored in NAME
1013  *       20 = lookup by 20 byte fingerprint which is stored in NAME
1014  * Caller must provide an empty PK, if the pubkey_algo is filled in, only
1015  * a key of this algo will be returned.
1016  * If ret_keyblock is not NULL, the complete keyblock is returned also
1017  * and the caller must release it.
1018  */
1019 static int
1020 lookup( GETKEY_CTX *retctx, PKT_public_key *pk, int mode, u32 *keyid,
1021         const char *name, KBNODE *ret_keyblock, int primary )
1022 {
1023     struct getkey_ctx_s help_ctx;
1024     GETKEY_CTX ctx;
1025     int rc;
1026
1027     if( !retctx )
1028         ctx = &help_ctx;
1029     else {
1030         ctx = m_alloc( sizeof *ctx );
1031         *retctx = ctx;
1032     }
1033
1034     memset( ctx, 0, sizeof *ctx );
1035     ctx->mode = mode;
1036     if( keyid ) {
1037         ctx->keyid[0] = keyid[0];
1038         ctx->keyid[1] = keyid[1];
1039     }
1040     if( retctx ) {
1041         ctx->namebuf = name? m_strdup(name) : NULL;
1042         ctx->name = ctx->namebuf;
1043     }
1044     else
1045         ctx->name = name;
1046     ctx->primary = primary;
1047     rc = lookup_read( ctx, pk, ret_keyblock );
1048     if( !retctx )
1049         lookup_close( ctx );
1050     return rc;
1051 }
1052
1053 static void
1054 lookup_close( GETKEY_CTX ctx )
1055 {
1056     enum_keyblocks( 2, &ctx->kbpos, NULL ); /* close */
1057     m_free( ctx->namebuf );
1058 }
1059
1060 static int
1061 lookup_read( GETKEY_CTX ctx, PKT_public_key *pk, KBNODE *ret_keyblock )
1062 {
1063     int rc;
1064     KBNODE k;
1065     int oldmode = set_packet_list_mode(0);
1066     byte namehash[20];
1067     int use_namehash=0;
1068
1069     /* try the quick functions */
1070     if( !ctx->count ) {
1071         k = NULL;
1072         switch( ctx->mode ) {
1073           case 10:
1074           case 11:
1075             rc = locate_keyblock_by_keyid( &ctx->kbpos, ctx->keyid,
1076                                                         ctx->mode==10, 0 );
1077             if( !rc )
1078                 rc = read_keyblock( &ctx->kbpos, &ctx->keyblock );
1079             if( !rc )
1080                 k = find_by_keyid( ctx->keyblock, pk, ctx->keyid, ctx->mode );
1081             break;
1082
1083           case 16:
1084           case 20:
1085             rc = locate_keyblock_by_fpr( &ctx->kbpos, ctx->name, ctx->mode, 0 );
1086             if( !rc )
1087                 rc = read_keyblock( &ctx->kbpos, &ctx->keyblock );
1088             if( !rc )
1089                 k = find_by_fpr( ctx->keyblock, pk, ctx->name, ctx->mode );
1090             break;
1091
1092           default: rc = G10ERR_UNSUPPORTED;
1093         }
1094         if( !rc ) {
1095             if( !k ) {
1096                 log_error("lookup: key has been located but was not found\n");
1097                 rc = G10ERR_INV_KEYRING;
1098             }
1099             else
1100                 finish_lookup( ctx->keyblock, pk, k, namehash, 0, ctx->primary );
1101         }
1102     }
1103     else
1104         rc = G10ERR_UNSUPPORTED;
1105
1106     /* if this was not possible, loop over all keyblocks
1107      * fixme: If one of the resources in the quick functions above
1108      *        works, but the key was not found, we will not find it
1109      *        in the other resources */
1110     if( rc == G10ERR_UNSUPPORTED ) {
1111         if( !ctx->count )
1112             rc = enum_keyblocks( 0, &ctx->kbpos, &ctx->keyblock );
1113         else
1114             rc = 0;
1115         if( !rc ) {
1116             while( !(rc = enum_keyblocks( 1, &ctx->kbpos, &ctx->keyblock )) ) {
1117                 /* fixme: we donĀ“t enum the complete keyblock, but
1118                  * use the first match and that continue with the next keyblock
1119                  */
1120                 if( ctx->mode < 10 )
1121                     k = find_by_name( ctx->keyblock, pk, ctx->name, ctx->mode,
1122                                                     namehash, &use_namehash);
1123                 else if( ctx->mode == 10 ||ctx-> mode == 11 )
1124                     k = find_by_keyid( ctx->keyblock, pk, ctx->keyid,
1125                                                                 ctx->mode );
1126                 else if( ctx->mode == 15 )
1127                     k = find_first( ctx->keyblock, pk );
1128                 else if( ctx->mode == 16 || ctx->mode == 20 )
1129                     k = find_by_fpr( ctx->keyblock, pk, ctx->name, ctx->mode );
1130                 else
1131                     BUG();
1132                 if( k ) {
1133                     finish_lookup( ctx->keyblock, pk, k, namehash,
1134                                                  use_namehash, ctx->primary );
1135                     break; /* found */
1136                 }
1137                 release_kbnode( ctx->keyblock );
1138                 ctx->keyblock = NULL;
1139             }
1140         }
1141         if( rc && rc != -1 )
1142             log_error("enum_keyblocks failed: %s\n", g10_errstr(rc));
1143     }
1144
1145     if( !rc ) {
1146         if( ret_keyblock ) {
1147             *ret_keyblock = ctx->keyblock;
1148             ctx->keyblock = NULL;
1149         }
1150     }
1151     else if( rc == -1 )
1152         rc = G10ERR_NO_PUBKEY;
1153
1154     release_kbnode( ctx->keyblock );
1155     ctx->keyblock = NULL;
1156     set_packet_list_mode(oldmode);
1157     if( opt.debug & DBG_MEMSTAT_VALUE ) {
1158         static int initialized;
1159
1160         if( !initialized ) {
1161             initialized = 1;
1162             atexit( print_stats );
1163         }
1164
1165         assert( ctx->mode < DIM(lkup_stats) );
1166         lkup_stats[ctx->mode].any = 1;
1167         if( !rc )
1168             lkup_stats[ctx->mode].okay_count++;
1169         else if ( rc == G10ERR_NO_PUBKEY )
1170             lkup_stats[ctx->mode].nokey_count++;
1171         else
1172             lkup_stats[ctx->mode].error_count++;
1173     }
1174
1175     ctx->last_rc = rc;
1176     ctx->count++;
1177     return rc;
1178 }
1179
1180
1181 /****************
1182  * Ditto for secret keys
1183  */
1184 static int
1185 lookup_sk( PKT_secret_key *sk, int mode,  u32 *keyid, const char *name,
1186            int primary )
1187 {
1188     int rc;
1189     KBNODE keyblock = NULL;
1190     KBPOS kbpos;
1191     int oldmode = set_packet_list_mode(0);
1192
1193     rc = enum_keyblocks( 5 /* open secret */, &kbpos, &keyblock );
1194     if( rc ) {
1195         if( rc == -1 )
1196             rc = G10ERR_NO_SECKEY;
1197         else if( rc )
1198             log_error("enum_keyblocks(open secret) failed: %s\n", g10_errstr(rc) );
1199         goto leave;
1200     }
1201
1202     while( !(rc = enum_keyblocks( 1, &kbpos, &keyblock )) ) {
1203         KBNODE k, kk;
1204         if( mode < 10 ) { /* name lookup */
1205             for(k=keyblock; k; k = k->next ) {
1206                 if( k->pkt->pkttype == PKT_USER_ID
1207                     && !compare_name( k->pkt->pkt.user_id->name,
1208                                       k->pkt->pkt.user_id->len, name, mode)) {
1209                     /* we found a matching name, look for the key */
1210                     for(kk=keyblock; kk; kk = kk->next ) {
1211                         if( (    kk->pkt->pkttype == PKT_SECRET_KEY
1212                               || kk->pkt->pkttype == PKT_SECRET_SUBKEY )
1213                             && ( !sk->pubkey_algo
1214                                  || sk->pubkey_algo
1215                                     == kk->pkt->pkt.secret_key->pubkey_algo)
1216                             && ( !sk->pubkey_usage
1217                                  || !check_pubkey_algo2(
1218                                        kk->pkt->pkt.secret_key->pubkey_algo,
1219                                                            sk->pubkey_usage ))
1220                           )
1221                             break;
1222                     }
1223                     if( kk ) {
1224                         u32 aki[2];
1225                         keyid_from_sk( kk->pkt->pkt.secret_key, aki );
1226                         cache_user_id( k->pkt->pkt.user_id, aki );
1227                         k = kk;
1228                         break;
1229                     }
1230                     else
1231                         log_error("No key for userid (in sk)\n");
1232                 }
1233             }
1234         }
1235         else { /* keyid or fingerprint lookup */
1236             if( DBG_CACHE && (mode== 10 || mode==11) ) {
1237                 log_debug("lookup_sk keyid=%08lx%08lx req_algo=%d mode=%d\n",
1238                                 (ulong)keyid[0], (ulong)keyid[1],
1239                                  sk->pubkey_algo, mode );
1240             }
1241             for(k=keyblock; k; k = k->next ) {
1242                 if(    k->pkt->pkttype == PKT_SECRET_KEY
1243                     || k->pkt->pkttype == PKT_SECRET_SUBKEY ) {
1244                     if( mode == 10 || mode == 11 ) {
1245                         u32 aki[2];
1246                         keyid_from_sk( k->pkt->pkt.secret_key, aki );
1247                         if( DBG_CACHE ) {
1248                             log_debug("             aki=%08lx%08lx algo=%d\n",
1249                                             (ulong)aki[0], (ulong)aki[1],
1250                                     k->pkt->pkt.secret_key->pubkey_algo    );
1251                         }
1252                         if( aki[1] == keyid[1]
1253                             && ( mode == 10 || aki[0] == keyid[0] )
1254                             && ( !sk->pubkey_algo
1255                                  || sk->pubkey_algo
1256                                     == k->pkt->pkt.secret_key->pubkey_algo) ){
1257                             /* cache the userid */
1258                             for(kk=keyblock; kk; kk = kk->next )
1259                                 if( kk->pkt->pkttype == PKT_USER_ID )
1260                                     break;
1261                             if( kk )
1262                                 cache_user_id( kk->pkt->pkt.user_id, aki );
1263                             else
1264                                 log_error("No userid for key\n");
1265                             break; /* found */
1266                         }
1267                     }
1268                     else if( mode == 15 ) { /* get the first key */
1269                         if( !sk->pubkey_algo
1270                             || sk->pubkey_algo
1271                                   == k->pkt->pkt.secret_key->pubkey_algo )
1272                             break;
1273                     }
1274                     else if( mode == 16 || mode == 20 ) {
1275                         size_t an;
1276                         byte afp[MAX_FINGERPRINT_LEN];
1277
1278                         fingerprint_from_sk(k->pkt->pkt.secret_key, afp, &an );
1279                         if( an == mode && !memcmp( afp, name, an)
1280                             && ( !sk->pubkey_algo
1281                                  || sk->pubkey_algo
1282                                     == k->pkt->pkt.secret_key->pubkey_algo) ) {
1283                             break;
1284                         }
1285                     }
1286                     else
1287                         BUG();
1288                 } /* end compare secret keys */
1289             }
1290         }
1291         if( k ) { /* found */
1292             assert(    k->pkt->pkttype == PKT_SECRET_KEY
1293                     || k->pkt->pkttype == PKT_SECRET_SUBKEY );
1294             assert( keyblock->pkt->pkttype == PKT_SECRET_KEY );
1295             if( primary && !sk->pubkey_usage )
1296                 copy_secret_key( sk, keyblock->pkt->pkt.secret_key );
1297             else
1298                 copy_secret_key( sk, k->pkt->pkt.secret_key );
1299             break; /* enumeration */
1300         }
1301         release_kbnode( keyblock );
1302         keyblock = NULL;
1303     }
1304     if( rc == -1 )
1305         rc = G10ERR_NO_SECKEY;
1306     else if( rc )
1307         log_error("enum_keyblocks(read) failed: %s\n", g10_errstr(rc));
1308
1309   leave:
1310     enum_keyblocks( 2, &kbpos, &keyblock ); /* close */
1311     release_kbnode( keyblock );
1312     set_packet_list_mode(oldmode);
1313     return rc;
1314 }
1315
1316
1317
1318 /****************
1319  * Enumerate all primary secret keys.  Caller must use these procedure:
1320  *  1) create a void pointer and initialize it to NULL
1321  *  2) pass this void pointer by reference to this function
1322  *     and provide space for the secret key (pass a buffer for sk)
1323  *  3) call this function as long as it does not return -1
1324  *     to indicate EOF.
1325  *  4) Always call this function a last time with SK set to NULL,
1326  *     so that can free it's context.
1327  *
1328  *
1329  */
1330 int
1331 enum_secret_keys( void **context, PKT_secret_key *sk, int with_subkeys )
1332 {
1333     int rc=0;
1334     PACKET pkt;
1335     int save_mode;
1336     struct {
1337         int eof;
1338         int sequence;
1339         const char *name;
1340         IOBUF iobuf;
1341     } *c = *context;
1342
1343
1344     if( !c ) { /* make a new context */
1345         c = m_alloc_clear( sizeof *c );
1346         *context = c;
1347         c->sequence = 0;
1348         c->name = enum_keyblock_resources( &c->sequence, 1 );
1349     }
1350
1351     if( !sk ) { /* free the context */
1352         if( c->iobuf )
1353             iobuf_close(c->iobuf);
1354         m_free( c );
1355         *context = NULL;
1356         return 0;
1357     }
1358
1359     if( c->eof )
1360         return -1;
1361
1362     /* FIXME: This assumes a plain keyring file */
1363     for( ; c->name; c->name = enum_keyblock_resources( &c->sequence, 1 ) ) {
1364         if( !c->iobuf ) {
1365             if( !(c->iobuf = iobuf_open( c->name ) ) ) {
1366                 log_error("enum_secret_keys: can't open '%s'\n", c->name );
1367                 continue; /* try next file */
1368             }
1369         }
1370
1371         save_mode = set_packet_list_mode(0);
1372         init_packet(&pkt);
1373         while( (rc=parse_packet(c->iobuf, &pkt)) != -1 ) {
1374             if( rc )
1375                 ; /* e.g. unknown packet */
1376             else if( pkt.pkttype == PKT_SECRET_KEY
1377                      || ( with_subkeys && pkt.pkttype == PKT_SECRET_SUBKEY ) ) {
1378                 copy_secret_key( sk, pkt.pkt.secret_key );
1379                 set_packet_list_mode(save_mode);
1380                 return 0; /* found */
1381             }
1382             free_packet(&pkt);
1383         }
1384         set_packet_list_mode(save_mode);
1385         iobuf_close(c->iobuf); c->iobuf = NULL;
1386     }
1387     c->eof = 1;
1388     return -1;
1389 }
1390
1391
1392 /****************
1393  * Return a string with a printable representation of the user_id.
1394  * this string must be freed by m_free.
1395  */
1396 char*
1397 get_user_id_string( u32 *keyid )
1398 {
1399     user_id_db_t r;
1400     char *p;
1401     int pass=0;
1402     /* try it two times; second pass reads from key resources */
1403     do {
1404         for(r=user_id_db; r; r = r->next )
1405             if( r->keyid[0] == keyid[0] && r->keyid[1] == keyid[1] ) {
1406                 p = m_alloc( r->len + 10 );
1407                 sprintf(p, "%08lX %.*s", (ulong)keyid[1], r->len, r->name );
1408                 return p;
1409             }
1410     } while( ++pass < 2 && !get_pubkey( NULL, keyid ) );
1411     p = m_alloc( 15 );
1412     sprintf(p, "%08lX [?]", (ulong)keyid[1] );
1413     return p;
1414 }
1415
1416 char*
1417 get_long_user_id_string( u32 *keyid )
1418 {
1419     user_id_db_t r;
1420     char *p;
1421     int pass=0;
1422     /* try it two times; second pass reads from key resources */
1423     do {
1424         for(r=user_id_db; r; r = r->next )
1425             if( r->keyid[0] == keyid[0] && r->keyid[1] == keyid[1] ) {
1426                 p = m_alloc( r->len + 20 );
1427                 sprintf(p, "%08lX%08lX %.*s",
1428                           (ulong)keyid[0], (ulong)keyid[1], r->len, r->name );
1429                 return p;
1430             }
1431     } while( ++pass < 2 && !get_pubkey( NULL, keyid ) );
1432     p = m_alloc( 25 );
1433     sprintf(p, "%08lX%08lX [?]", (ulong)keyid[0], (ulong)keyid[1] );
1434     return p;
1435 }
1436
1437 char*
1438 get_user_id( u32 *keyid, size_t *rn )
1439 {
1440     user_id_db_t r;
1441     char *p;
1442     int pass=0;
1443     /* try it two times; second pass reads from key resources */
1444     do {
1445         for(r=user_id_db; r; r = r->next )
1446             if( r->keyid[0] == keyid[0] && r->keyid[1] == keyid[1] ) {
1447                 p = m_alloc( r->len );
1448                 memcpy(p, r->name, r->len );
1449                 *rn = r->len;
1450                 return p;
1451             }
1452     } while( ++pass < 2 && !get_pubkey( NULL, keyid ) );
1453     p = m_alloc( 19 );
1454     memcpy(p, "[User id not found]", 19 );
1455     *rn = 19;
1456     return p;
1457 }
1458
1459