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