Ready for version 0.4.4
[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             memset(fprint+16, 4, 0);
387             for(j=0; j < 16; j++, s+=2 ) {
388                 int c = hextobyte( s );
389                 if( c == -1 )
390                     return 0;
391                 fprint[j] = c;
392             }
393             mode = 16;
394         }
395         else if( i == 40 || ( i == 41 && *s == '0' ) ) { /* sha1/rmd160 fprint*/
396             if( i==33 )
397                 s++;
398             for(j=0; j < 20; j++, s+=2 ) {
399                 int c = hextobyte( s );
400                 if( c == -1 )
401                     return 0;
402                 fprint[j] = c;
403             }
404             mode = 20;
405         }
406         else
407             return 0;
408     }
409     else if( *s == '=' ) { /* exact search */
410         mode = 1;
411         s++;
412     }
413     else if( *s == '*' ) { /* substring search */
414         mode = 2;
415         s++;
416     }
417     else if( *s == '<' ) { /* an email address */
418         mode = 3;
419     }
420     else if( *s == '@' ) { /* a part of an email address */
421         mode = 4;
422         s++;
423     }
424     else if( *s == '.' ) { /* an email address, compare from end */
425         mode = 5;
426         s++;
427     }
428     else if( *s == '#' ) { /* use local id */
429         return 0;
430     }
431     else if( !*s )  /* empty string */
432         return 0;
433     else
434         mode = 2;
435
436     if( retstr )
437         *retstr = s;
438     if( retlen )
439         *retlen = strlen(s);
440
441     return mode;
442 }
443
444
445
446 /****************
447  * Try to get the pubkey by the userid. This function looks for the
448  * first pubkey certificate which has the given name in a user_id.
449  * if pk has the pubkey algo set, the function will only return
450  * a pubkey with that algo.
451  */
452
453 static int
454 key_byname( int secret, GETKEY_CTX *retctx,
455             PKT_public_key *pk, PKT_secret_key *sk,
456             const char *name, KBNODE *ret_kb )
457 {
458     int internal = 0;
459     int rc = 0;
460     const char *s;
461     u32 keyid[2] = {0}; /* init to avoid compiler warning */
462     byte fprint[20];
463     int mode;
464
465     mode = classify_user_id( name, keyid, fprint, &s, NULL );
466     if( !mode ) {
467         rc = G10ERR_INV_USER_ID;
468         goto leave;
469     }
470
471     if( secret ) {
472         if( !sk ) {
473             sk = m_alloc_clear( sizeof *sk );
474             internal++;
475         }
476         rc = mode < 16? lookup_sk( sk, mode, keyid, s, 1 )
477                       : lookup_sk( sk, mode, keyid, fprint, 1 );
478     }
479     else {
480         if( !pk ) {
481             pk = m_alloc_clear( sizeof *pk );
482             internal++;
483         }
484         rc = mode < 16? lookup( retctx, pk, mode, keyid, s, ret_kb, 1 )
485                       : lookup( retctx, pk, mode, keyid, fprint, ret_kb, 1 );
486     }
487
488
489   leave:
490     if( internal && secret )
491         m_free( sk );
492     else if( internal )
493         m_free( pk );
494     return rc;
495 }
496
497 int
498 get_pubkey_byname( GETKEY_CTX *retctx, PKT_public_key *pk,
499                    const char *name, KBNODE *ret_keyblock )
500 {
501     int rc;
502
503     if( !pk ) {
504         /* fixme: key_byname should not need a pk in this case */
505         pk = m_alloc_clear( sizeof *pk );
506         rc = key_byname( 0, retctx, pk, NULL, name, ret_keyblock );
507         free_public_key( pk );
508     }
509     else
510         rc = key_byname( 0, retctx, pk, NULL, name, ret_keyblock );
511     return rc;
512 }
513
514 int
515 get_pubkey_next( GETKEY_CTX ctx, PKT_public_key *pk, KBNODE *ret_keyblock )
516 {
517     int rc;
518
519     if( !pk ) {
520         /* fixme: lookup_read should not need a pk in this case */
521         pk = m_alloc_clear( sizeof *pk );
522         rc = lookup_read( ctx, pk, ret_keyblock );
523         free_public_key( pk );
524     }
525     else
526         rc = lookup_read( ctx, pk, ret_keyblock );
527     return rc;
528 }
529
530 void
531 get_pubkey_end( GETKEY_CTX ctx )
532 {
533     if( ctx ) {
534         lookup_close( ctx );
535         m_free( ctx );
536     }
537 }
538
539 /****************
540  * Search for a key with the given fingerprint.
541  */
542 int
543 get_pubkey_byfprint( PKT_public_key *pk, const byte *fprint, size_t fprint_len)
544 {
545     int rc;
546
547     if( fprint_len == 20 || fprint_len == 16 )
548         rc = lookup( NULL, pk, fprint_len, NULL, fprint, NULL, 0 );
549     else
550         rc = G10ERR_GENERAL; /* Oops */
551     return rc;
552 }
553
554 /****************
555  * Search for a key with the given fingerprint and return the
556  * complete keyblock which may have more than only this key.
557  */
558 int
559 get_keyblock_byfprint( KBNODE *ret_keyblock, const byte *fprint,
560                                                 size_t fprint_len )
561 {
562     int rc;
563     PKT_public_key *pk = m_alloc_clear( sizeof *pk );
564
565     if( fprint_len == 20 || fprint_len == 16 )
566         rc = lookup( NULL, pk, fprint_len, NULL, fprint, ret_keyblock, 0 );
567     else
568         rc = G10ERR_GENERAL; /* Oops */
569
570     free_public_key( pk );
571     return rc;
572 }
573
574 /****************
575  * Get a secret key and store it into sk
576  */
577 int
578 get_seckey( PKT_secret_key *sk, u32 *keyid )
579 {
580     int rc;
581
582     rc = lookup_sk( sk, 11, keyid, NULL, 0 );
583     if( !rc ) {
584         /* check the secret key (this may prompt for a passprase to
585          * unlock the secret key
586          */
587         rc = check_secret_key( sk, 0 );
588     }
589
590     return rc;
591 }
592
593 /****************
594  * Check whether the secret key is available
595  * Returns: 0 := key is available
596  *          G10ERR_NO_SECKEY := not availabe
597  */
598 int
599 seckey_available( u32 *keyid )
600 {
601     PKT_secret_key *sk;
602     int rc;
603
604     sk = m_alloc_clear( sizeof *sk );
605     rc = lookup_sk( sk, 11, keyid, NULL, 0 );
606     free_secret_key( sk );
607     return rc;
608 }
609
610
611
612 /****************
613  * Get a secret key by name and store it into sk
614  * If NAME is NULL use the default key
615  */
616 int
617 get_seckey_byname( PKT_secret_key *sk, const char *name, int unprotect )
618 {
619     int rc;
620
621     if( !name && opt.def_secret_key && *opt.def_secret_key )
622         rc = key_byname( 1, NULL, NULL, sk, opt.def_secret_key, NULL );
623     else if( !name ) /* use the first one as default key */
624         rc = lookup_sk( sk, 15, NULL, NULL, 1 );
625     else
626         rc = key_byname( 1, NULL, NULL, sk, name, NULL );
627     if( !rc && unprotect )
628         rc = check_secret_key( sk, 0 );
629
630     return rc;
631 }
632
633
634 static int
635 compare_name( const char *uid, size_t uidlen, const char *name, int mode )
636 {
637     int i;
638     const char *s, *se;
639
640     if( mode == 1 ) {  /* exact match */
641         for(i=0; name[i] && uidlen; i++, uidlen-- )
642             if( uid[i] != name[i] )
643                 break;
644         if( !uidlen && !name[i] )
645             return 0; /* found */
646     }
647     else if( mode == 2 ) { /* case insensitive substring */
648         if( memistr( uid, uidlen, name ) )
649             return 0;
650     }
651     else if( mode >= 3 && mode <= 5 ) { /* look at the email address */
652         for( i=0, s= uid; i < uidlen && *s != '<'; s++, i++ )
653             ;
654         if( i < uidlen )  {
655             /* skip opening delim and one char and look for the closing one*/
656             s++; i++;
657             for( se=s+1, i++; i < uidlen && *se != '>'; se++, i++ )
658                 ;
659             if( i < uidlen ) {
660                 i = se - s;
661                 if( mode == 3 ) { /* exact email address */
662                     if( strlen(name)-2 == i && !memicmp( s, name+1, i) )
663                         return 0;
664                 }
665                 else if( mode == 4 ) {  /* email substring */
666                     if( memistr( s, i, name ) )
667                         return 0;
668                 }
669                 else { /* email from end */
670                     /* nyi */
671                 }
672             }
673         }
674     }
675     else
676         BUG();
677
678     return -1; /* not found */
679 }
680
681
682
683 /****************
684  * Assume that knode points to a public key packet  and keyblock is
685  * the entire keyblock.  This function adds all relevant information from
686  * a selfsignature to the public key.
687  */
688
689 static void
690 merge_one_pk_and_selfsig( KBNODE keyblock, KBNODE knode )
691 {
692     PKT_public_key *pk = knode->pkt->pkt.public_key;
693     PKT_signature *sig;
694     KBNODE k;
695     u32 kid[2];
696
697     assert(    knode->pkt->pkttype == PKT_PUBLIC_KEY
698             || knode->pkt->pkttype == PKT_PUBLIC_SUBKEY );
699
700     if( pk->version < 4 )
701         return; /* this is only needed for version >=4 packets */
702
703     /* find the selfsignature */
704     if( knode->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
705         k = find_kbnode( keyblock, PKT_PUBLIC_KEY );
706         if( !k )
707            BUG(); /* keyblock without primary key!!! */
708         keyid_from_pk( knode->pkt->pkt.public_key, kid );
709     }
710     else
711         keyid_from_pk( pk, kid );
712     for(k=keyblock; k; k = k->next ) {
713         if( k->pkt->pkttype == PKT_SIGNATURE
714             && (sig=k->pkt->pkt.signature)->sig_class >= 0x10
715             && sig->sig_class <= 0x30
716             && sig->keyid[0] == kid[0]
717             && sig->keyid[1] == kid[1]
718             && sig->version > 3 ) {
719             /* okay this is (the first) self-signature which can be used
720              * FIXME: We should only use this if the signature is valid
721              *        but this is time consuming - we must provide another
722              *        way to handle this
723              */
724             const byte *p;
725             p = parse_sig_subpkt( sig->hashed_data, SIGSUBPKT_KEY_EXPIRE, NULL );
726             pk->expiredate = p? pk->timestamp + buffer_to_u32(p):0;
727             /* fixme: add usage etc. to pk */
728             break;
729         }
730     }
731 }
732
733
734 /****************
735  * merge all selfsignatures with the keys.
736  */
737 void
738 merge_keys_and_selfsig( KBNODE keyblock )
739 {
740     PKT_public_key *pk = NULL;
741     PKT_secret_key *sk = NULL;
742     PKT_signature *sig;
743     KBNODE k;
744     u32 kid[2] = { 0, 0 };
745
746     for(k=keyblock; k; k = k->next ) {
747         if( k->pkt->pkttype == PKT_PUBLIC_KEY
748             || k->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
749             pk = k->pkt->pkt.public_key; sk = NULL;
750             if( pk->version < 4 )
751                 pk = NULL; /* not needed for old keys */
752             else if( k->pkt->pkttype == PKT_PUBLIC_KEY )
753                 keyid_from_pk( pk, kid );
754         }
755         else if( k->pkt->pkttype == PKT_SECRET_KEY
756             || k->pkt->pkttype == PKT_SECRET_SUBKEY ) {
757             pk = NULL; sk = k->pkt->pkt.secret_key;
758             if( sk->version < 4 )
759                 sk = NULL;
760             else if( k->pkt->pkttype == PKT_SECRET_KEY )
761                 keyid_from_sk( sk, kid );
762         }
763         else if( (pk || sk ) && k->pkt->pkttype == PKT_SIGNATURE
764                  && (sig=k->pkt->pkt.signature)->sig_class >= 0x10
765                  && sig->sig_class <= 0x30 && sig->version > 3
766                  && sig->keyid[0] == kid[0] && sig->keyid[1] == kid[1] ) {
767             /* okay this is (the first) self-signature which can be used
768              * FIXME: We should only use this if the signature is valid
769              *        but this is time consuming - we must provide another
770              *        way to handle this
771              */
772             const byte *p;
773             p = parse_sig_subpkt( sig->hashed_data, SIGSUBPKT_KEY_EXPIRE, NULL );
774             if( pk ) {
775                 pk->expiredate = p? pk->timestamp + buffer_to_u32(p):0;
776                 /* fixme: add usage etc. */
777                 pk = NULL; /* use only the first self signature */
778             }
779             else {
780                 sk->expiredate = p? sk->timestamp + buffer_to_u32(p):0;
781                 sk = NULL; /* use only the first self signature */
782             }
783         }
784     }
785 }
786
787
788 static KBNODE
789 find_by_name( KBNODE keyblock, PKT_public_key *pk, const char *name,
790               int mode, byte *namehash, int *use_namehash )
791 {
792     KBNODE k, kk;
793
794     for(k=keyblock; k; k = k->next ) {
795         if( k->pkt->pkttype == PKT_USER_ID
796             && !compare_name( k->pkt->pkt.user_id->name,
797                               k->pkt->pkt.user_id->len, name, mode)) {
798             /* we found a matching name, look for the key */
799             for(kk=keyblock; kk; kk = kk->next ) {
800                 if( (    kk->pkt->pkttype == PKT_PUBLIC_KEY
801                       || kk->pkt->pkttype == PKT_PUBLIC_SUBKEY )
802                     && ( !pk->pubkey_algo
803                          || pk->pubkey_algo
804                             == kk->pkt->pkt.public_key->pubkey_algo)
805                     && ( !pk->pubkey_usage
806                          || !check_pubkey_algo2(
807                                kk->pkt->pkt.public_key->pubkey_algo,
808                                                    pk->pubkey_usage ))
809                   )
810                     break;
811             }
812             if( kk ) {
813                 u32 aki[2];
814                 keyid_from_pk( kk->pkt->pkt.public_key, aki );
815                 cache_user_id( k->pkt->pkt.user_id, aki );
816                 rmd160_hash_buffer( namehash,
817                                     k->pkt->pkt.user_id->name,
818                                     k->pkt->pkt.user_id->len );
819                 *use_namehash = 1;
820                 return kk;
821             }
822             else if( is_RSA(pk->pubkey_algo) )
823                 log_error("RSA key cannot be used in this version\n");
824             else
825                 log_error("No key for userid\n");
826         }
827     }
828     return NULL;
829 }
830
831
832 static KBNODE
833 find_by_keyid( KBNODE keyblock, PKT_public_key *pk, u32 *keyid, int mode )
834 {
835     KBNODE k;
836
837     if( DBG_CACHE )
838         log_debug("lookup keyid=%08lx%08lx req_algo=%d mode=%d\n",
839                    (ulong)keyid[0], (ulong)keyid[1], pk->pubkey_algo, mode );
840
841     for(k=keyblock; k; k = k->next ) {
842         if(    k->pkt->pkttype == PKT_PUBLIC_KEY
843             || k->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
844             u32 aki[2];
845             keyid_from_pk( k->pkt->pkt.public_key, aki );
846             if( DBG_CACHE )
847                 log_debug("         aki=%08lx%08lx algo=%d\n",
848                                 (ulong)aki[0], (ulong)aki[1],
849                                  k->pkt->pkt.public_key->pubkey_algo    );
850
851             if( aki[1] == keyid[1]
852                 && ( mode == 10 || aki[0] == keyid[0] )
853                 && ( !pk->pubkey_algo
854                      || pk->pubkey_algo
855                         == k->pkt->pkt.public_key->pubkey_algo) ){
856                 KBNODE kk;
857                 /* cache the userid */
858                 for(kk=keyblock; kk; kk = kk->next )
859                     if( kk->pkt->pkttype == PKT_USER_ID )
860                         break;
861                 if( kk )
862                     cache_user_id( kk->pkt->pkt.user_id, aki );
863                 else
864                     log_error("No userid for key\n");
865                 return k; /* found */
866             }
867         }
868     }
869     return NULL;
870 }
871
872
873 static KBNODE
874 find_first( KBNODE keyblock, PKT_public_key *pk )
875 {
876     KBNODE k;
877
878     for(k=keyblock; k; k = k->next ) {
879         if(    k->pkt->pkttype == PKT_PUBLIC_KEY
880             || k->pkt->pkttype == PKT_PUBLIC_SUBKEY )
881         {
882             if( !pk->pubkey_algo
883                 || pk->pubkey_algo == k->pkt->pkt.public_key->pubkey_algo )
884                 return k;
885         }
886     }
887     return NULL;
888 }
889
890
891 static KBNODE
892 find_by_fpr( KBNODE keyblock, PKT_public_key *pk, const char *name, int mode )
893 {
894     KBNODE k;
895
896     for(k=keyblock; k; k = k->next ) {
897         if(    k->pkt->pkttype == PKT_PUBLIC_KEY
898             || k->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
899             byte afp[MAX_FINGERPRINT_LEN];
900             size_t an;
901
902             fingerprint_from_pk(k->pkt->pkt.public_key, afp, &an );
903
904             if( DBG_CACHE ) {
905                 u32 aki[2];
906                 keyid_from_pk( k->pkt->pkt.public_key, aki );
907                 log_debug("         aki=%08lx%08lx algo=%d mode=%d an=%u\n",
908                                 (ulong)aki[0], (ulong)aki[1],
909                         k->pkt->pkt.public_key->pubkey_algo, mode, an );
910             }
911
912             if( an == mode
913                 && !memcmp( afp, name, an)
914                 && ( !pk->pubkey_algo
915                      || pk->pubkey_algo == k->pkt->pkt.public_key->pubkey_algo) )
916                 return k;
917         }
918     }
919     return NULL;
920 }
921
922
923 static void
924 finish_lookup( KBNODE keyblock, PKT_public_key *pk, KBNODE k, byte *namehash,
925                                                int use_namehash, int primary )
926 {
927     assert(    k->pkt->pkttype == PKT_PUBLIC_KEY
928             || k->pkt->pkttype == PKT_PUBLIC_SUBKEY );
929     assert( keyblock->pkt->pkttype == PKT_PUBLIC_KEY );
930     if( primary && !pk->pubkey_usage ) {
931         copy_public_key_new_namehash( pk, keyblock->pkt->pkt.public_key,
932                                       use_namehash? namehash:NULL);
933         merge_one_pk_and_selfsig( keyblock, keyblock );
934     }
935     else {
936         if( primary && pk->pubkey_usage
937             && check_pubkey_algo2( k->pkt->pkt.public_key->pubkey_algo,
938                        pk->pubkey_usage ) == G10ERR_WR_PUBKEY_ALGO ) {
939             /* if the usage is not correct, try to use a subkey */
940             KBNODE save_k = k;
941
942             k = NULL;
943             /* kludge for pgp 5: which doesn't accept type 20:
944              * try to use a type 16 subkey instead */
945             if( pk->pubkey_usage == PUBKEY_USAGE_ENC ) {
946                 for( k = save_k; k; k = k->next ) {
947                     if( k->pkt->pkttype == PKT_PUBLIC_SUBKEY
948                         && k->pkt->pkt.public_key->pubkey_algo
949                             == PUBKEY_ALGO_ELGAMAL_E
950                         && !check_pubkey_algo2(
951                                 k->pkt->pkt.public_key->pubkey_algo,
952                                                  pk->pubkey_usage ) )
953                         break;
954                 }
955             }
956
957             if( !k ) {
958                 for(k = save_k ; k; k = k->next ) {
959                     if( k->pkt->pkttype == PKT_PUBLIC_SUBKEY
960                         && !check_pubkey_algo2(
961                                 k->pkt->pkt.public_key->pubkey_algo,
962                                                  pk->pubkey_usage ) )
963                         break;
964                 }
965             }
966             if( !k )
967                 k = save_k;
968             else
969                 log_info(_("using secondary key %08lX "
970                            "instead of primary key %08lX\n"),
971                       (ulong)keyid_from_pk( k->pkt->pkt.public_key, NULL),
972                       (ulong)keyid_from_pk( save_k->pkt->pkt.public_key, NULL)
973                         );
974         }
975
976         copy_public_key_new_namehash( pk, k->pkt->pkt.public_key,
977                                       use_namehash? namehash:NULL);
978         merge_one_pk_and_selfsig( keyblock, k );
979     }
980 }
981
982 /****************
983  * Lookup a key by scanning all keyresources
984  *   mode 1 = lookup by NAME (exact)
985  *        2 = lookup by NAME (substring)
986  *        3 = lookup by NAME (email address)
987  *        4 = email address (substring)
988  *        5 = email address (compare from end)
989  *       10 = lookup by short KEYID (don't care about keyid[0])
990  *       11 = lookup by long  KEYID
991  *       15 = Get the first key.
992  *       16 = lookup by 16 byte fingerprint which is stored in NAME
993  *       20 = lookup by 20 byte fingerprint which is stored in NAME
994  * Caller must provide an empty PK, if the pubkey_algo is filled in, only
995  * a key of this algo will be returned.
996  * If ret_keyblock is not NULL, the complete keyblock is returned also
997  * and the caller must release it.
998  */
999 static int
1000 lookup( GETKEY_CTX *retctx, PKT_public_key *pk, int mode, u32 *keyid,
1001         const char *name, KBNODE *ret_keyblock, int primary )
1002 {
1003     struct getkey_ctx_s help_ctx;
1004     GETKEY_CTX ctx;
1005     int rc;
1006
1007     if( !retctx )
1008         ctx = &help_ctx;
1009     else {
1010         ctx = m_alloc( sizeof *ctx );
1011         *retctx = ctx;
1012     }
1013
1014     memset( ctx, 0, sizeof *ctx );
1015     ctx->mode = mode;
1016     if( keyid ) {
1017         ctx->keyid[0] = keyid[0];
1018         ctx->keyid[1] = keyid[1];
1019     }
1020     if( retctx ) {
1021         ctx->namebuf = name? m_strdup(name) : NULL;
1022         ctx->name = ctx->namebuf;
1023     }
1024     else
1025         ctx->name = name;
1026     ctx->primary = primary;
1027     rc = lookup_read( ctx, pk, ret_keyblock );
1028     if( !retctx )
1029         lookup_close( ctx );
1030     return rc;
1031 }
1032
1033 static void
1034 lookup_close( GETKEY_CTX ctx )
1035 {
1036     enum_keyblocks( 2, &ctx->kbpos, NULL ); /* close */
1037     m_free( ctx->namebuf );
1038 }
1039
1040 static int
1041 lookup_read( GETKEY_CTX ctx, PKT_public_key *pk, KBNODE *ret_keyblock )
1042 {
1043     int rc;
1044     KBNODE k;
1045     int oldmode = set_packet_list_mode(0);
1046     byte namehash[20];
1047     int use_namehash=0;
1048
1049     /* try the quick functions */
1050     if( !ctx->count ) {
1051         k = NULL;
1052         switch( ctx->mode ) {
1053           case 10:
1054           case 11:
1055             rc = locate_keyblock_by_keyid( &ctx->kbpos, ctx->keyid,
1056                                                         ctx->mode==10, 0 );
1057             if( !rc )
1058                 rc = read_keyblock( &ctx->kbpos, &ctx->keyblock );
1059             if( !rc )
1060                 k = find_by_keyid( ctx->keyblock, pk, ctx->keyid, ctx->mode );
1061             break;
1062
1063           case 16:
1064           case 20:
1065             rc = locate_keyblock_by_fpr( &ctx->kbpos, ctx->name, ctx->mode, 0 );
1066             if( !rc )
1067                 rc = read_keyblock( &ctx->kbpos, &ctx->keyblock );
1068             if( !rc )
1069                 k = find_by_fpr( ctx->keyblock, pk, ctx->name, ctx->mode );
1070             break;
1071
1072           default: rc = G10ERR_UNSUPPORTED;
1073         }
1074         if( !rc ) {
1075             if( !k ) {
1076                 log_error("lookup: key has been located but was not found\n");
1077                 rc = G10ERR_INV_KEYRING;
1078             }
1079             else
1080                 finish_lookup( ctx->keyblock, pk, k, namehash, 0, ctx->primary );
1081         }
1082     }
1083     else
1084         rc = G10ERR_UNSUPPORTED;
1085
1086     /* if this was not possible, loop over all keyblocks
1087      * fixme: If one of the resources in the quick functions above
1088      *        works, but the key was not found, we will not find it
1089      *        in the other resources */
1090     if( rc == G10ERR_UNSUPPORTED ) {
1091         if( !ctx->count )
1092             rc = enum_keyblocks( 0, &ctx->kbpos, &ctx->keyblock );
1093         else
1094             rc = 0;
1095         if( !rc ) {
1096             while( !(rc = enum_keyblocks( 1, &ctx->kbpos, &ctx->keyblock )) ) {
1097                 /* fixme: we donĀ“t enum the complete keyblock, but
1098                  * use the first match and that continue with the next keyblock
1099                  */
1100                 if( ctx->mode < 10 )
1101                     k = find_by_name( ctx->keyblock, pk, ctx->name, ctx->mode,
1102                                                     namehash, &use_namehash);
1103                 else if( ctx->mode == 10 ||ctx-> mode == 11 )
1104                     k = find_by_keyid( ctx->keyblock, pk, ctx->keyid,
1105                                                                 ctx->mode );
1106                 else if( ctx->mode == 15 )
1107                     k = find_first( ctx->keyblock, pk );
1108                 else if( ctx->mode == 16 || ctx->mode == 20 )
1109                     k = find_by_fpr( ctx->keyblock, pk, ctx->name, ctx->mode );
1110                 else
1111                     BUG();
1112                 if( k ) {
1113                     finish_lookup( ctx->keyblock, pk, k, namehash,
1114                                                  use_namehash, ctx->primary );
1115                     break; /* found */
1116                 }
1117                 release_kbnode( ctx->keyblock );
1118                 ctx->keyblock = NULL;
1119             }
1120         }
1121         if( rc && rc != -1 )
1122             log_error("enum_keyblocks failed: %s\n", g10_errstr(rc));
1123     }
1124
1125     if( !rc ) {
1126         if( ret_keyblock ) {
1127             *ret_keyblock = ctx->keyblock;
1128             ctx->keyblock = NULL;
1129         }
1130     }
1131     else if( rc == -1 )
1132         rc = G10ERR_NO_PUBKEY;
1133
1134     release_kbnode( ctx->keyblock );
1135     ctx->keyblock = NULL;
1136     set_packet_list_mode(oldmode);
1137     if( opt.debug & DBG_MEMSTAT_VALUE ) {
1138         static int initialized;
1139
1140         if( !initialized ) {
1141             initialized = 1;
1142             atexit( print_stats );
1143         }
1144
1145         assert( ctx->mode < DIM(lkup_stats) );
1146         lkup_stats[ctx->mode].any = 1;
1147         if( !rc )
1148             lkup_stats[ctx->mode].okay_count++;
1149         else if ( rc == G10ERR_NO_PUBKEY )
1150             lkup_stats[ctx->mode].nokey_count++;
1151         else
1152             lkup_stats[ctx->mode].error_count++;
1153     }
1154
1155     ctx->last_rc = rc;
1156     ctx->count++;
1157     return rc;
1158 }
1159
1160
1161 /****************
1162  * Ditto for secret keys
1163  */
1164 static int
1165 lookup_sk( PKT_secret_key *sk, int mode,  u32 *keyid, const char *name,
1166            int primary )
1167 {
1168     int rc;
1169     KBNODE keyblock = NULL;
1170     KBPOS kbpos;
1171     int oldmode = set_packet_list_mode(0);
1172
1173     rc = enum_keyblocks( 5 /* open secret */, &kbpos, &keyblock );
1174     if( rc ) {
1175         if( rc == -1 )
1176             rc = G10ERR_NO_SECKEY;
1177         else if( rc )
1178             log_error("enum_keyblocks(open secret) failed: %s\n", g10_errstr(rc) );
1179         goto leave;
1180     }
1181
1182     while( !(rc = enum_keyblocks( 1, &kbpos, &keyblock )) ) {
1183         KBNODE k, kk;
1184         if( mode < 10 ) { /* name lookup */
1185             for(k=keyblock; k; k = k->next ) {
1186                 if( k->pkt->pkttype == PKT_USER_ID
1187                     && !compare_name( k->pkt->pkt.user_id->name,
1188                                       k->pkt->pkt.user_id->len, name, mode)) {
1189                     /* we found a matching name, look for the key */
1190                     for(kk=keyblock; kk; kk = kk->next ) {
1191                         if( (    kk->pkt->pkttype == PKT_SECRET_KEY
1192                               || kk->pkt->pkttype == PKT_SECRET_SUBKEY )
1193                             && ( !sk->pubkey_algo
1194                                  || sk->pubkey_algo
1195                                     == kk->pkt->pkt.secret_key->pubkey_algo)
1196                             && ( !sk->pubkey_usage
1197                                  || !check_pubkey_algo2(
1198                                        kk->pkt->pkt.secret_key->pubkey_algo,
1199                                                            sk->pubkey_usage ))
1200                           )
1201                             break;
1202                     }
1203                     if( kk ) {
1204                         u32 aki[2];
1205                         keyid_from_sk( kk->pkt->pkt.secret_key, aki );
1206                         cache_user_id( k->pkt->pkt.user_id, aki );
1207                         k = kk;
1208                         break;
1209                     }
1210                     else
1211                         log_error("No key for userid (in sk)\n");
1212                 }
1213             }
1214         }
1215         else { /* keyid or fingerprint lookup */
1216             if( DBG_CACHE && (mode== 10 || mode==11) ) {
1217                 log_debug("lookup_sk keyid=%08lx%08lx req_algo=%d mode=%d\n",
1218                                 (ulong)keyid[0], (ulong)keyid[1],
1219                                  sk->pubkey_algo, mode );
1220             }
1221             for(k=keyblock; k; k = k->next ) {
1222                 if(    k->pkt->pkttype == PKT_SECRET_KEY
1223                     || k->pkt->pkttype == PKT_SECRET_SUBKEY ) {
1224                     if( mode == 10 || mode == 11 ) {
1225                         u32 aki[2];
1226                         keyid_from_sk( k->pkt->pkt.secret_key, aki );
1227                         if( DBG_CACHE ) {
1228                             log_debug("             aki=%08lx%08lx algo=%d\n",
1229                                             (ulong)aki[0], (ulong)aki[1],
1230                                     k->pkt->pkt.secret_key->pubkey_algo    );
1231                         }
1232                         if( aki[1] == keyid[1]
1233                             && ( mode == 10 || aki[0] == keyid[0] )
1234                             && ( !sk->pubkey_algo
1235                                  || sk->pubkey_algo
1236                                     == k->pkt->pkt.secret_key->pubkey_algo) ){
1237                             /* cache the userid */
1238                             for(kk=keyblock; kk; kk = kk->next )
1239                                 if( kk->pkt->pkttype == PKT_USER_ID )
1240                                     break;
1241                             if( kk )
1242                                 cache_user_id( kk->pkt->pkt.user_id, aki );
1243                             else
1244                                 log_error("No userid for key\n");
1245                             break; /* found */
1246                         }
1247                     }
1248                     else if( mode == 15 ) { /* get the first key */
1249                         if( !sk->pubkey_algo
1250                             || sk->pubkey_algo
1251                                   == k->pkt->pkt.secret_key->pubkey_algo )
1252                             break;
1253                     }
1254                     else if( mode == 16 || mode == 20 ) {
1255                         size_t an;
1256                         byte afp[MAX_FINGERPRINT_LEN];
1257
1258                         fingerprint_from_sk(k->pkt->pkt.secret_key, afp, &an );
1259                         if( an == mode && !memcmp( afp, name, an)
1260                             && ( !sk->pubkey_algo
1261                                  || sk->pubkey_algo
1262                                     == k->pkt->pkt.secret_key->pubkey_algo) ) {
1263                             break;
1264                         }
1265                     }
1266                     else
1267                         BUG();
1268                 } /* end compare secret keys */
1269             }
1270         }
1271         if( k ) { /* found */
1272             assert(    k->pkt->pkttype == PKT_SECRET_KEY
1273                     || k->pkt->pkttype == PKT_SECRET_SUBKEY );
1274             assert( keyblock->pkt->pkttype == PKT_SECRET_KEY );
1275             if( primary && !sk->pubkey_usage )
1276                 copy_secret_key( sk, keyblock->pkt->pkt.secret_key );
1277             else
1278                 copy_secret_key( sk, k->pkt->pkt.secret_key );
1279             break; /* enumeration */
1280         }
1281         release_kbnode( keyblock );
1282         keyblock = NULL;
1283     }
1284     if( rc == -1 )
1285         rc = G10ERR_NO_SECKEY;
1286     else if( rc )
1287         log_error("enum_keyblocks(read) failed: %s\n", g10_errstr(rc));
1288
1289   leave:
1290     enum_keyblocks( 2, &kbpos, &keyblock ); /* close */
1291     release_kbnode( keyblock );
1292     set_packet_list_mode(oldmode);
1293     return rc;
1294 }
1295
1296
1297
1298 /****************
1299  * Enumerate all primary secret keys.  Caller must use these procedure:
1300  *  1) create a void pointer and initialize it to NULL
1301  *  2) pass this void pointer by reference to this function
1302  *     and provide space for the secret key (pass a buffer for sk)
1303  *  3) call this function as long as it does not return -1
1304  *     to indicate EOF.
1305  *  4) Always call this function a last time with SK set to NULL,
1306  *     so that can free it's context.
1307  *
1308  *
1309  */
1310 int
1311 enum_secret_keys( void **context, PKT_secret_key *sk, int with_subkeys )
1312 {
1313     int rc=0;
1314     PACKET pkt;
1315     int save_mode;
1316     struct {
1317         int eof;
1318         int sequence;
1319         const char *name;
1320         IOBUF iobuf;
1321     } *c = *context;
1322
1323
1324     if( !c ) { /* make a new context */
1325         c = m_alloc_clear( sizeof *c );
1326         *context = c;
1327         c->sequence = 0;
1328         c->name = enum_keyblock_resources( &c->sequence, 1 );
1329     }
1330
1331     if( !sk ) { /* free the context */
1332         if( c->iobuf )
1333             iobuf_close(c->iobuf);
1334         m_free( c );
1335         *context = NULL;
1336         return 0;
1337     }
1338
1339     if( c->eof )
1340         return -1;
1341
1342     /* FIXME: This assumes a plain keyring file */
1343     for( ; c->name; c->name = enum_keyblock_resources( &c->sequence, 1 ) ) {
1344         if( !c->iobuf ) {
1345             if( !(c->iobuf = iobuf_open( c->name ) ) ) {
1346                 log_error("enum_secret_keys: can't open '%s'\n", c->name );
1347                 continue; /* try next file */
1348             }
1349         }
1350
1351         save_mode = set_packet_list_mode(0);
1352         init_packet(&pkt);
1353         while( (rc=parse_packet(c->iobuf, &pkt)) != -1 ) {
1354             if( rc )
1355                 ; /* e.g. unknown packet */
1356             else if( pkt.pkttype == PKT_SECRET_KEY
1357                      || ( with_subkeys && pkt.pkttype == PKT_SECRET_SUBKEY ) ) {
1358                 copy_secret_key( sk, pkt.pkt.secret_key );
1359                 set_packet_list_mode(save_mode);
1360                 return 0; /* found */
1361             }
1362             free_packet(&pkt);
1363         }
1364         set_packet_list_mode(save_mode);
1365         iobuf_close(c->iobuf); c->iobuf = NULL;
1366     }
1367     c->eof = 1;
1368     return -1;
1369 }
1370
1371
1372 /****************
1373  * Return a string with a printable representation of the user_id.
1374  * this string must be freed by m_free.
1375  */
1376 char*
1377 get_user_id_string( u32 *keyid )
1378 {
1379     user_id_db_t r;
1380     char *p;
1381     int pass=0;
1382     /* try it two times; second pass reads from key resources */
1383     do {
1384         for(r=user_id_db; r; r = r->next )
1385             if( r->keyid[0] == keyid[0] && r->keyid[1] == keyid[1] ) {
1386                 p = m_alloc( r->len + 10 );
1387                 sprintf(p, "%08lX %.*s", (ulong)keyid[1], r->len, r->name );
1388                 return p;
1389             }
1390     } while( ++pass < 2 && !get_pubkey( NULL, keyid ) );
1391     p = m_alloc( 15 );
1392     sprintf(p, "%08lX [?]", (ulong)keyid[1] );
1393     return p;
1394 }
1395
1396 char*
1397 get_user_id( u32 *keyid, size_t *rn )
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 );
1407                 memcpy(p, r->name, r->len );
1408                 *rn = r->len;
1409                 return p;
1410             }
1411     } while( ++pass < 2 && !get_pubkey( NULL, keyid ) );
1412     p = m_alloc( 19 );
1413     memcpy(p, "[User id not found]", 19 );
1414     *rn = 19;
1415     return p;
1416 }
1417
1418