See ChangeLog: Wed Feb 10 17:15:39 CET 1999 Werner Koch
[gnupg.git] / g10 / getkey.c
1 /* getkey.c -  Get a key from the database
2  *      Copyright (C) 1998, 1999 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 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <assert.h>
26 #include <ctype.h>
27 #include "util.h"
28 #include "packet.h"
29 #include "memory.h"
30 #include "iobuf.h"
31 #include "keydb.h"
32 #include "options.h"
33 #include "main.h"
34 #include "i18n.h"
35
36 #define MAX_UNK_CACHE_ENTRIES 1000   /* we use a linked list - so I guess
37                                       * this is a reasonable limit */
38 #define MAX_PK_CACHE_ENTRIES    50
39 #define MAX_UID_CACHE_ENTRIES   50
40
41 /* A map of the all characters valid used for word_match()
42  * Valid characters are in in this table converted to uppercase.
43  * because the upper 128 bytes have special meaning, we assume
44  * that they are all valid.
45  * Note: We must use numerical values here in case that this program
46  * will be converted to those little blue HAL9000s with their strange
47  * EBCDIC character set (user ids are UTF-8). */
48 static const byte word_match_chars[256] = {
49   /* 00 */  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
50   /* 08 */  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
51   /* 10 */  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
52   /* 18 */  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
53   /* 20 */  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
54   /* 28 */  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
55   /* 30 */  0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
56   /* 38 */  0x38, 0x39, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
57   /* 40 */  0x00, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
58   /* 48 */  0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
59   /* 50 */  0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
60   /* 58 */  0x58, 0x59, 0x5a, 0x00, 0x00, 0x00, 0x00, 0x00,
61   /* 60 */  0x00, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
62   /* 68 */  0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
63   /* 70 */  0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
64   /* 78 */  0x58, 0x59, 0x5a, 0x00, 0x00, 0x00, 0x00, 0x00,
65   /* 80 */  0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
66   /* 88 */  0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
67   /* 90 */  0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
68   /* 98 */  0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
69   /* a0 */  0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
70   /* a8 */  0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
71   /* b0 */  0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
72   /* b8 */  0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
73   /* c0 */  0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
74   /* c8 */  0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
75   /* d0 */  0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
76   /* d8 */  0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
77   /* e0 */  0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7,
78   /* e8 */  0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
79   /* f0 */  0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
80   /* f8 */  0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
81 };
82
83 typedef struct {
84     int mode;
85     u32 keyid[2];
86     byte fprint[20];
87     char *namebuf;
88     const char *name;
89 } getkey_item_t;
90
91 struct getkey_ctx_s {
92     /* make an array or a linked list from dome fields */
93     int primary;
94     KBNODE keyblock;
95     KBPOS kbpos;
96     int last_rc;
97     ulong count;
98     int not_allocated;
99     int nitems;
100     getkey_item_t items[1];
101 };
102
103
104
105
106
107 #if 0
108 static struct {
109     int any;
110     int okay_count;
111     int nokey_count;
112     int error_count;
113 } lkup_stats[21];
114 #endif
115
116
117
118 #if MAX_UNK_CACHE_ENTRIES
119   typedef struct keyid_list {
120       struct keyid_list *next;
121       u32 keyid[2];
122   } *keyid_list_t;
123   static keyid_list_t unknown_keyids;
124   static int unk_cache_entries;   /* number of entries in unknown keys cache */
125   static int unk_cache_disabled;
126 #endif
127
128 #if MAX_PK_CACHE_ENTRIES
129   typedef struct pk_cache_entry {
130       struct pk_cache_entry *next;
131       u32 keyid[2];
132       PKT_public_key *pk;
133   } *pk_cache_entry_t;
134   static pk_cache_entry_t pk_cache;
135   static int pk_cache_entries;   /* number of entries in pk cache */
136   static int pk_cache_disabled;
137 #endif
138
139 #if MAX_UID_CACHE_ENTRIES < 5
140     #error we really need the userid cache
141 #endif
142 typedef struct user_id_db {
143     struct user_id_db *next;
144     u32 keyid[2];
145     int len;
146     char name[1];
147 } *user_id_db_t;
148 static user_id_db_t user_id_db;
149 static int uid_cache_entries;   /* number of entries in uid cache */
150
151
152
153 static char* prepare_word_match( const byte *name );
154 static int lookup_pk( GETKEY_CTX ctx, PKT_public_key *pk, KBNODE *ret_kb );
155 static int lookup_sk( GETKEY_CTX ctx, PKT_secret_key *sk, KBNODE *ret_kb );
156
157
158 #if 0
159 static void
160 print_stats()
161 {
162     int i;
163     for(i=0; i < DIM(lkup_stats); i++ ) {
164         if( lkup_stats[i].any )
165             fprintf(stderr,
166                     "lookup stats: mode=%-2d  ok=%-6d  nokey=%-6d  err=%-6d\n",
167                     i,
168                     lkup_stats[i].okay_count,
169                     lkup_stats[i].nokey_count,
170                     lkup_stats[i].error_count );
171     }
172 }
173 #endif
174
175
176 static void
177 cache_public_key( PKT_public_key *pk )
178 {
179   #if MAX_PK_CACHE_ENTRIES
180     pk_cache_entry_t ce;
181     u32 keyid[2];
182
183     if( pk_cache_disabled )
184         return;
185
186     if( is_ELGAMAL(pk->pubkey_algo)
187         || pk->pubkey_algo == PUBKEY_ALGO_DSA
188         || is_RSA(pk->pubkey_algo) ) {
189         keyid_from_pk( pk, keyid );
190     }
191     else
192         return; /* don't know how to get the keyid */
193
194     for( ce = pk_cache; ce; ce = ce->next )
195         if( ce->keyid[0] == keyid[0] && ce->keyid[1] == keyid[1] ) {
196             if( DBG_CACHE )
197                 log_debug("cache_public_key: already in cache\n");
198             return;
199         }
200
201     if( pk_cache_entries >= MAX_PK_CACHE_ENTRIES ) {
202         /* fixme: use another algorithm to free some cache slots */
203         pk_cache_disabled=1;
204         if( opt.verbose > 1 )
205             log_info(_("too many entries in pk cache - disabled\n"));
206         return;
207     }
208     pk_cache_entries++;
209     ce = m_alloc( sizeof *ce );
210     ce->next = pk_cache;
211     pk_cache = ce;
212     ce->pk = copy_public_key( NULL, pk );
213     ce->keyid[0] = keyid[0];
214     ce->keyid[1] = keyid[1];
215   #endif
216 }
217
218
219 /****************
220  * Store the association of keyid and userid
221  */
222 void
223 cache_user_id( PKT_user_id *uid, u32 *keyid )
224 {
225     user_id_db_t r;
226
227     for(r=user_id_db; r; r = r->next )
228         if( r->keyid[0] == keyid[0] && r->keyid[1] == keyid[1] ) {
229             if( DBG_CACHE )
230                log_debug("cache_user_id: already in cache\n");
231             return;
232         }
233
234     if( uid_cache_entries >= MAX_UID_CACHE_ENTRIES ) {
235         /* fixme: use another algorithm to free some cache slots */
236         r = user_id_db;
237         user_id_db = r->next;
238         m_free(r);
239         uid_cache_entries--;
240     }
241     r = m_alloc( sizeof *r + uid->len-1 );
242     r->keyid[0] = keyid[0];
243     r->keyid[1] = keyid[1];
244     r->len = uid->len;
245     memcpy(r->name, uid->name, r->len);
246     r->next = user_id_db;
247     user_id_db = r;
248     uid_cache_entries++;
249 }
250
251
252 void
253 getkey_disable_caches()
254 {
255   #if MAX_UNK_CACHE_ENTRIES
256     {
257         keyid_list_t kl, kl2;
258         for( kl = unknown_keyids; kl; kl = kl2 ) {
259             kl2 = kl->next;
260             m_free(kl);
261         }
262         unknown_keyids = NULL;
263         unk_cache_disabled = 1;
264     }
265   #endif
266   #if MAX_PK_CACHE_ENTRIES
267     {
268         pk_cache_entry_t ce, ce2;
269
270         for( ce = pk_cache; ce; ce = ce2 ) {
271             ce2 = ce->next;
272             free_public_key( ce->pk );
273             m_free( ce );
274         }
275         pk_cache_disabled=1;
276         pk_cache_entries = 0;
277         pk_cache = NULL;
278     }
279   #endif
280     /* fixme: disable user id cache ? */
281 }
282
283
284 /****************
285  * Get a public key and store it into the allocated pk
286  * can be called with PK set to NULL to just read it into some
287  * internal structures.
288  */
289 int
290 get_pubkey( PKT_public_key *pk, u32 *keyid )
291 {
292     int internal = 0;
293     int rc = 0;
294
295   #if MAX_UNK_CACHE_ENTRIES
296     {   /* let's see whether we checked the keyid already */
297         keyid_list_t kl;
298         for( kl = unknown_keyids; kl; kl = kl->next )
299             if( kl->keyid[0] == keyid[0] && kl->keyid[1] == keyid[1] )
300                 return G10ERR_NO_PUBKEY; /* already checked and not found */
301     }
302   #endif
303
304   #if MAX_PK_CACHE_ENTRIES
305     {   /* Try to get it from the cache */
306         pk_cache_entry_t ce;
307         for( ce = pk_cache; ce; ce = ce->next ) {
308             if( ce->keyid[0] == keyid[0] && ce->keyid[1] == keyid[1] ) {
309                 if( pk )
310                     copy_public_key( pk, ce->pk );
311                 return 0;
312             }
313         }
314     }
315   #endif
316     /* more init stuff */
317     if( !pk ) {
318         pk = m_alloc_clear( sizeof *pk );
319         internal++;
320     }
321
322
323     /* do a lookup */
324     {   struct getkey_ctx_s ctx;
325         memset( &ctx, 0, sizeof ctx );
326         ctx.not_allocated = 1;
327         ctx.nitems = 1;
328         ctx.items[0].mode = 11;
329         ctx.items[0].keyid[0] = keyid[0];
330         ctx.items[0].keyid[1] = keyid[1];
331         rc = lookup_pk( &ctx, pk, NULL );
332         get_pubkey_end( &ctx );
333     }
334     if( !rc )
335         goto leave;
336
337   #if MAX_UNK_CACHE_ENTRIES
338     /* not found: store it for future reference */
339     if( unk_cache_disabled )
340         ;
341     else if( ++unk_cache_entries > MAX_UNK_CACHE_ENTRIES ) {
342         unk_cache_disabled = 1;
343         if( opt.verbose > 1 )
344             log_info(_("too many entries in unk cache - disabled\n"));
345     }
346     else {
347         keyid_list_t kl;
348
349         kl = m_alloc( sizeof *kl );
350         kl->keyid[0] = keyid[0];
351         kl->keyid[1] = keyid[1];
352         kl->next = unknown_keyids;
353         unknown_keyids = kl;
354     }
355   #endif
356     rc = G10ERR_NO_PUBKEY;
357
358   leave:
359     if( !rc )
360         cache_public_key( pk );
361     if( internal )
362         free_public_key(pk);
363     return rc;
364 }
365
366
367 /****************
368  * Get a secret key and store it into sk
369  */
370 int
371 get_seckey( PKT_secret_key *sk, u32 *keyid )
372 {
373     int rc;
374     struct getkey_ctx_s ctx;
375
376     memset( &ctx, 0, sizeof ctx );
377     ctx.not_allocated = 1;
378     ctx.nitems = 1;
379     ctx.items[0].mode = 11;
380     ctx.items[0].keyid[0] = keyid[0];
381     ctx.items[0].keyid[1] = keyid[1];
382     rc = lookup_sk( &ctx, sk, NULL );
383     get_seckey_end( &ctx );
384     if( !rc ) {
385         /* check the secret key (this may prompt for a passprase to
386          * unlock the secret key
387          */
388         rc = check_secret_key( sk, 0 );
389     }
390
391     return rc;
392 }
393
394
395 /****************
396  * Get the primary secret key and store it into sk
397  * Note: This function does not unprotect the key!
398  */
399 int
400 get_primary_seckey( PKT_secret_key *sk, u32 *keyid )
401 {
402     struct getkey_ctx_s ctx;
403     int rc;
404
405     memset( &ctx, 0, sizeof ctx );
406     ctx.not_allocated = 1;
407     ctx.primary = 1;
408     ctx.nitems = 1;
409     ctx.items[0].mode = 11;
410     ctx.items[0].keyid[0] = keyid[0];
411     ctx.items[0].keyid[1] = keyid[1];
412     rc = lookup_sk( &ctx, sk, NULL );
413     get_seckey_end( &ctx );
414     return rc;
415 }
416
417
418
419 /****************
420  * Check whether the secret key is available
421  * Returns: 0 := key is available
422  *          G10ERR_NO_SECKEY := not availabe
423  */
424 int
425 seckey_available( u32 *keyid )
426 {
427     int rc;
428     struct getkey_ctx_s ctx;
429     PKT_secret_key *sk;
430
431     sk = m_alloc_clear( sizeof *sk );
432     memset( &ctx, 0, sizeof ctx );
433     ctx.not_allocated = 1;
434     ctx.nitems = 1;
435     ctx.items[0].mode = 11;
436     ctx.items[0].keyid[0] = keyid[0];
437     ctx.items[0].keyid[1] = keyid[1];
438     rc = lookup_sk( &ctx, sk, NULL );
439     get_seckey_end( &ctx );
440     free_secret_key( sk );
441     return rc;
442 }
443
444
445
446 static int
447 hextobyte( const byte *s )
448 {
449     int c;
450
451     if( *s >= '0' && *s <= '9' )
452         c = 16 * (*s - '0');
453     else if( *s >= 'A' && *s <= 'F' )
454         c = 16 * (10 + *s - 'A');
455     else if( *s >= 'a' && *s <= 'f' )
456         c = 16 * (10 + *s - 'a');
457     else
458         return -1;
459     s++;
460     if( *s >= '0' && *s <= '9' )
461         c += *s - '0';
462     else if( *s >= 'A' && *s <= 'F' )
463         c += 10 + *s - 'A';
464     else if( *s >= 'a' && *s <= 'f' )
465         c += 10 + *s - 'a';
466     else
467         return -1;
468     return c;
469 }
470
471
472
473 /****************
474  * Return the type of the user id:
475  *
476  *  0 = Invalid user ID
477  *  1 = exact match
478  *  2 = match a substring
479  *  3 = match an email address
480  *  4 = match a substring of an email address
481  *  5 = match an email address, but compare from end
482  *  6 = word match mode
483  * 10 = it is a short KEYID (don't care about keyid[0])
484  * 11 = it is a long  KEYID
485  * 16 = it is a 16 byte fingerprint
486  * 20 = it is a 20 byte fingerprint
487  *
488  * if fprint is not NULL, it should be an array of at least 20 bytes.
489  *
490  * Rules used:
491  * - If the username starts with 8,9,16 or 17 hex-digits (the first one
492  *   must be in the range 0..9), this is considered a keyid; depending
493  *   on the length a short or complete one.
494  * - If the username starts with 32,33,40 or 41 hex-digits (the first one
495  *   must be in the range 0..9), this is considered a fingerprint.
496  * - If the username starts with a left angle, we assume it is a complete
497  *   email address and look only at this part.
498  * - If the username starts with a '.', we assume it is the ending
499  *   part of an email address
500  * - If the username starts with an '@', we assume it is a part of an
501  *   email address
502  * - If the userid start with an '=' an exact compare is done.
503  * - If the userid starts with a '*' a case insensitive substring search is
504  *   done (This is the default).
505  * - If the userid starts with a '+' we will compare individual words
506  *   and a match requires that all the words are in the userid.
507  *   Words are delimited by white space or "()<>[]{}.@-+_,;/&!"
508  *   (note that you can't search for these characters). Compare
509  *   is not case sensitive.
510  */
511
512 int
513 classify_user_id( const char *name, u32 *keyid, byte *fprint,
514                   const char **retstr, size_t *retlen )
515 {
516     const char *s;
517     int mode = 0;
518
519     /* check what kind of name it is */
520     for(s = name; *s && isspace(*s); s++ )
521         ;
522     if( isdigit( *s ) ) { /* a keyid or a fingerprint */
523         int i, j;
524         char buf[9];
525
526         if( *s == '0' && s[1] == 'x' && isxdigit(s[2]) )
527             s += 2; /*kludge to allow 0x034343434 */
528         for(i=0; isxdigit(s[i]); i++ )
529             ;
530         if( s[i] && !isspace(s[i]) ) /* not terminated by EOS or blank*/
531             return 0;
532         else if( i == 8 || (i == 9 && *s == '0') ) { /* short keyid */
533             if( i==9 )
534                 s++;
535             if( keyid ) {
536                 keyid[0] = 0;
537                 keyid[1] = strtoul( s, NULL, 16 );
538             }
539             mode = 10;
540         }
541         else if( i == 16 || (i == 17 && *s == '0') ) { /* complete keyid */
542             if( i==17 )
543                 s++;
544             mem2str(buf, s, 9 );
545             keyid[0] = strtoul( buf, NULL, 16 );
546             keyid[1] = strtoul( s+8, NULL, 16 );
547             mode = 11;
548         }
549         else if( i == 32 || ( i == 33 && *s == '0' ) ) { /* md5 fingerprint */
550             if( i==33 )
551                 s++;
552             if( fprint ) {
553                 memset(fprint+16, 4, 0);
554                 for(j=0; j < 16; j++, s+=2 ) {
555                     int c = hextobyte( s );
556                     if( c == -1 )
557                         return 0;
558                     fprint[j] = c;
559                 }
560             }
561             mode = 16;
562         }
563         else if( i == 40 || ( i == 41 && *s == '0' ) ) { /* sha1/rmd160 fprint*/
564             if( i==33 )
565                 s++;
566             if( fprint ) {
567                 for(j=0; j < 20; j++, s+=2 ) {
568                     int c = hextobyte( s );
569                     if( c == -1 )
570                         return 0;
571                     fprint[j] = c;
572                 }
573             }
574             mode = 20;
575         }
576         else
577             return 0;
578     }
579     else if( *s == '=' ) { /* exact search */
580         mode = 1;
581         s++;
582     }
583     else if( *s == '*' ) { /* substring search */
584         mode = 2;
585         s++;
586     }
587     else if( *s == '<' ) { /* an email address */
588         mode = 3;
589     }
590     else if( *s == '@' ) { /* a part of an email address */
591         mode = 4;
592         s++;
593     }
594     else if( *s == '.' ) { /* an email address, compare from end */
595         mode = 5;
596         s++;
597     }
598     else if( *s == '+' ) { /* word match mode */
599         mode = 6;
600         s++;
601     }
602     else if( *s == '#' ) { /* use local id */
603         return 0;
604     }
605     else if( !*s )  /* empty string */
606         return 0;
607     else
608         mode = 2;
609
610     if( retstr )
611         *retstr = s;
612     if( retlen )
613         *retlen = strlen(s);
614
615     return mode;
616 }
617
618
619
620 /****************
621  * Try to get the pubkey by the userid. This function looks for the
622  * first pubkey certificate which has the given name in a user_id.
623  * if pk/sk has the pubkey algo set, the function will only return
624  * a pubkey with that algo.
625  * The caller must provide provide storage for either the pk or the sk.
626  * If ret_kb is not NULL the funtion will return the keyblock there.
627  */
628
629 static int
630 key_byname( GETKEY_CTX *retctx, STRLIST namelist,
631             PKT_public_key *pk, PKT_secret_key *sk, KBNODE *ret_kb )
632 {
633     int rc = 0;
634     int n;
635     STRLIST r;
636     GETKEY_CTX ctx;
637
638     assert( !pk ^ !sk );
639
640     /* build the search context */
641     /* Performance hint: Use a static buffer if there is only one name */
642     /*                   and we don't have mode 6 */
643     for(n=0, r=namelist; r; r = r->next )
644         n++;
645     ctx = m_alloc_clear( sizeof *ctx + (n-1)*sizeof ctx->items );
646     ctx->nitems = n;
647
648     for(n=0, r=namelist; r; r = r->next, n++ ) {
649         ctx->items[n].mode = classify_user_id( r->d,
650                                               ctx->items[n].keyid,
651                                               ctx->items[n].fprint,
652                                               &ctx->items[n].name,
653                                               NULL );
654         if( !ctx->items[n].mode ) {
655             m_free( ctx );
656             return G10ERR_INV_USER_ID;
657         }
658         if( ctx->items[n].mode == 6 ) {
659             ctx->items[n].namebuf = prepare_word_match(ctx->items[n].name);
660             ctx->items[n].name = ctx->items[n].namebuf;
661         }
662     }
663
664     /* and call the lookup function */
665     ctx->primary = 1; /* we want to look for the primary key only */
666     if( sk )
667         rc = lookup_sk( ctx, sk, ret_kb );
668     else
669         rc = lookup_pk( ctx, pk, ret_kb );
670
671     if( retctx ) /* caller wants the context */
672         *retctx = ctx;
673     else {
674         for(n=0; n < ctx->nitems; n++ )
675             m_free( ctx->items[n].namebuf );
676         m_free( ctx );
677     }
678
679     return rc;
680 }
681
682 int
683 get_pubkey_byname( GETKEY_CTX *retctx, PKT_public_key *pk,
684                    const char *name, KBNODE *ret_keyblock )
685 {
686     int rc;
687     STRLIST namelist = NULL;
688
689     add_to_strlist( &namelist, name );
690
691     if( !pk ) {
692         /* Performance Hint: key_byname should not need a pk here */
693         pk = m_alloc_clear( sizeof *pk );
694         rc = key_byname( retctx, namelist, pk, NULL, ret_keyblock );
695         free_public_key( pk );
696     }
697     else
698         rc = key_byname( retctx, namelist, pk, NULL, ret_keyblock );
699
700     free_strlist( namelist );
701     return rc;
702 }
703
704 int
705 get_pubkey_bynames( GETKEY_CTX *retctx, PKT_public_key *pk,
706                     STRLIST names, KBNODE *ret_keyblock )
707 {
708     int rc;
709
710     if( !pk ) {
711         /* Performance Hint: key_byname should not need a pk here */
712         pk = m_alloc_clear( sizeof *pk );
713         rc = key_byname( retctx, names, pk, NULL, ret_keyblock );
714         free_public_key( pk );
715     }
716     else
717         rc = key_byname( retctx, names, pk, NULL, ret_keyblock );
718
719     return rc;
720 }
721
722 int
723 get_pubkey_next( GETKEY_CTX ctx, PKT_public_key *pk, KBNODE *ret_keyblock )
724 {
725     int rc;
726
727     if( !pk ) {
728         /* Performance Hint: lookup_read should not need a pk in this case */
729         pk = m_alloc_clear( sizeof *pk );
730         rc = lookup_pk( ctx, pk, ret_keyblock );
731         free_public_key( pk );
732     }
733     else
734         rc = lookup_pk( ctx, pk, ret_keyblock );
735     return rc;
736 }
737
738 void
739 get_pubkey_end( GETKEY_CTX ctx )
740 {
741     if( ctx ) {
742         int n;
743
744         enum_keyblocks( 2, &ctx->kbpos, NULL ); /* close */
745         for(n=0; n < ctx->nitems; n++ )
746             m_free( ctx->items[n].namebuf );
747         if( !ctx->not_allocated )
748             m_free( ctx );
749     }
750 }
751
752 /****************
753  * Search for a key with the given fingerprint.
754  */
755 int
756 get_pubkey_byfprint( PKT_public_key *pk, const byte *fprint, size_t fprint_len)
757 {
758     int rc;
759
760     if( fprint_len == 20 || fprint_len == 16 ) {
761         struct getkey_ctx_s ctx;
762         memset( &ctx, 0, sizeof ctx );
763         ctx.not_allocated = 1;
764         ctx.nitems = 1;
765         ctx.items[0].mode = fprint_len;
766         memcpy( ctx.items[0].fprint, fprint, fprint_len );
767         rc = lookup_pk( &ctx, pk, NULL );
768         get_pubkey_end( &ctx );
769     }
770     else
771         rc = G10ERR_GENERAL; /* Oops */
772     return rc;
773 }
774
775 /****************
776  * Search for a key with the given fingerprint and return the
777  * complete keyblock which may have more than only this key.
778  */
779 int
780 get_keyblock_byfprint( KBNODE *ret_keyblock, const byte *fprint,
781                                                 size_t fprint_len )
782 {
783     int rc;
784     PKT_public_key *pk = m_alloc_clear( sizeof *pk );
785
786     if( fprint_len == 20 || fprint_len == 16 ) {
787         struct getkey_ctx_s ctx;
788         memset( &ctx, 0, sizeof ctx );
789         ctx.not_allocated = 1;
790         ctx.nitems = 1;
791         ctx.items[0].mode = fprint_len;
792         memcpy( ctx.items[0].fprint, fprint, fprint_len );
793         rc = lookup_pk( &ctx, pk, ret_keyblock );
794         get_pubkey_end( &ctx );
795     }
796     else
797         rc = G10ERR_GENERAL; /* Oops */
798
799     free_public_key( pk );
800     return rc;
801 }
802
803
804
805
806
807 /****************
808  * Get a secret key by name and store it into sk
809  * If NAME is NULL use the default key
810  */
811 int
812 get_seckey_byname( PKT_secret_key *sk, const char *name, int unprotect )
813 {
814     STRLIST namelist = NULL;
815     int rc;
816
817     if( !name && opt.def_secret_key && *opt.def_secret_key ) {
818         add_to_strlist( &namelist, opt.def_secret_key );
819         rc = key_byname( NULL, namelist, NULL, sk, NULL );
820     }
821     else if( !name ) { /* use the first one as default key */
822         struct getkey_ctx_s ctx;
823
824         memset( &ctx, 0, sizeof ctx );
825         ctx.not_allocated = 1;
826         ctx.primary = 1;
827         ctx.nitems = 1;
828         ctx.items[0].mode = 15;
829         rc = lookup_sk( &ctx, sk, NULL );
830         get_seckey_end( &ctx );
831     }
832     else {
833         add_to_strlist( &namelist, name );
834         rc = key_byname( NULL, namelist, NULL, sk, NULL );
835     }
836
837     free_strlist( namelist );
838
839     if( !rc && unprotect )
840         rc = check_secret_key( sk, 0 );
841
842     return rc;
843 }
844
845 int
846 get_seckey_bynames( GETKEY_CTX *retctx, PKT_secret_key *sk,
847                     STRLIST names, KBNODE *ret_keyblock )
848 {
849     int rc;
850
851     if( !sk ) {
852         /* Performance Hint: key_byname should not need a sk here */
853         sk = m_alloc_secure_clear( sizeof *sk );
854         rc = key_byname( retctx, names, NULL, sk, ret_keyblock );
855         free_secret_key( sk );
856     }
857     else
858         rc = key_byname( retctx, names, NULL, sk, ret_keyblock );
859
860     return rc;
861 }
862
863
864 int
865 get_seckey_next( GETKEY_CTX ctx, PKT_secret_key *sk, KBNODE *ret_keyblock )
866 {
867     int rc;
868
869     if( !sk ) {
870         /* Performance Hint: lookup_read should not need a pk in this case */
871         sk = m_alloc_secure_clear( sizeof *sk );
872         rc = lookup_sk( ctx, sk, ret_keyblock );
873         free_secret_key( sk );
874     }
875     else
876         rc = lookup_sk( ctx, sk, ret_keyblock );
877     return rc;
878 }
879
880 void
881 get_seckey_end( GETKEY_CTX ctx )
882 {
883     if( ctx ) {
884         int n;
885
886         enum_keyblocks( 2, &ctx->kbpos, NULL ); /* close */
887         for(n=0; n < ctx->nitems; n++ )
888             m_free( ctx->items[n].namebuf );
889         if( !ctx->not_allocated )
890             m_free( ctx );
891     }
892 }
893
894
895
896 /****************
897  * Do a word match (original user id starts with a '+').
898  * The pattern is already tokenized to a more suitable format:
899  * There are only the real words in it delimited by one space
900  * and all converted to uppercase.
901  *
902  * Returns: 0 if all words match.
903  *
904  * Note: This algorithm is a straightforward one and not very
905  *       fast.  It works for UTF-8 strings.  The uidlen should
906  *       be removed but due to the fact that old versions of
907  *       pgp don't use UTF-8 we still use the length; this should
908  *       be fixed in parse-packet (and replace \0 by some special
909  *       UTF-8 encoding)
910  */
911 static int
912 word_match( const byte *uid, size_t uidlen, const byte *pattern )
913 {
914     size_t wlen, n;
915     const byte *p;
916     const byte *s;
917
918     for( s=pattern; *s; ) {
919         do {
920             /* skip leading delimiters */
921             while( uidlen && !word_match_chars[*uid] )
922                 uid++, uidlen--;
923             /* get length of the word */
924             n = uidlen; p = uid;
925             while( n && word_match_chars[*p] )
926                 p++, n--;
927             wlen = p - uid;
928             /* and compare against the current word from pattern */
929             for(n=0, p=uid; n < wlen && s[n] != ' ' && s[n] ; n++, p++ ) {
930                 if( word_match_chars[*p] != s[n] )
931                     break;
932             }
933             if( n == wlen && (s[n] == ' ' || !s[n]) )
934                 break; /* found */
935             uid += wlen;
936             uidlen -= wlen;
937         } while( uidlen );
938         if( !uidlen )
939             return -1; /* not found */
940
941         /* advance to next word in pattern */
942         for(; *s != ' ' && *s ; s++ )
943             ;
944         if( *s )
945             s++ ;
946     }
947     return 0; /* found */
948 }
949
950 /****************
951  * prepare word word_match; that is parse the name and
952  * build the pattern.
953  * caller has to free the returned pattern
954  */
955 static char*
956 prepare_word_match( const byte *name )
957 {
958     byte *pattern, *p;
959     int c;
960
961     /* the original length is always enough for the pattern */
962     p = pattern = m_alloc(strlen(name)+1);
963     do {
964         /* skip leading delimiters */
965         while( *name && !word_match_chars[*name] )
966             name++;
967         /* copy as long as we don't have a delimiter and convert
968          * to uppercase.
969          * fixme: how can we handle utf8 uppercasing */
970         for( ; *name &&  (c=word_match_chars[*name]); name++ )
971             *p++ = c;
972         *p++ = ' '; /* append pattern delimiter */
973     } while( *name );
974     p[-1] = 0; /* replace last pattern delimiter by EOS */
975
976     return pattern;
977 }
978
979
980
981
982
983 static int
984 compare_name( const char *uid, size_t uidlen, const char *name, int mode )
985 {
986     int i;
987     const char *s, *se;
988
989     if( mode == 1 ) {  /* exact match */
990         for(i=0; name[i] && uidlen; i++, uidlen-- )
991             if( uid[i] != name[i] )
992                 break;
993         if( !uidlen && !name[i] )
994             return 0; /* found */
995     }
996     else if( mode == 2 ) { /* case insensitive substring */
997         if( memistr( uid, uidlen, name ) )
998             return 0;
999     }
1000     else if( mode >= 3 && mode <= 5 ) { /* look at the email address */
1001         for( i=0, s= uid; i < uidlen && *s != '<'; s++, i++ )
1002             ;
1003         if( i < uidlen )  {
1004             /* skip opening delim and one char and look for the closing one*/
1005             s++; i++;
1006             for( se=s+1, i++; i < uidlen && *se != '>'; se++, i++ )
1007                 ;
1008             if( i < uidlen ) {
1009                 i = se - s;
1010                 if( mode == 3 ) { /* exact email address */
1011                     if( strlen(name)-2 == i && !memicmp( s, name+1, i) )
1012                         return 0;
1013                 }
1014                 else if( mode == 4 ) {  /* email substring */
1015                     if( memistr( s, i, name ) )
1016                         return 0;
1017                 }
1018                 else { /* email from end */
1019                     /* nyi */
1020                 }
1021             }
1022         }
1023     }
1024     else if( mode == 6 )
1025         return word_match( uid, uidlen, name );
1026     else
1027         BUG();
1028
1029     return -1; /* not found */
1030 }
1031
1032
1033
1034 /****************
1035  * Assume that knode points to a public key packet  and keyblock is
1036  * the entire keyblock.  This function adds all relevant information from
1037  * a selfsignature to the public key.
1038  */
1039
1040 static void
1041 merge_one_pk_and_selfsig( KBNODE keyblock, KBNODE knode,
1042                           PKT_public_key *orig_pk )
1043 {
1044     PKT_public_key *pk = knode->pkt->pkt.public_key;
1045     PKT_signature *sig;
1046     KBNODE k;
1047     u32 kid[2];
1048     u32 sigdate = 0;
1049
1050     assert(    knode->pkt->pkttype == PKT_PUBLIC_KEY
1051             || knode->pkt->pkttype == PKT_PUBLIC_SUBKEY );
1052
1053     if( pk->version < 4 )
1054         return; /* this is only needed for version >=4 packets */
1055
1056
1057     /* find the selfsignature */
1058     if( knode->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
1059         k = find_kbnode( keyblock, PKT_PUBLIC_KEY );
1060         if( !k )
1061            BUG(); /* keyblock without primary key!!! */
1062         keyid_from_pk( knode->pkt->pkt.public_key, kid );
1063     }
1064     else
1065         keyid_from_pk( pk, kid );
1066
1067     for(k=knode->next; k; k = k->next ) {
1068         if( k->pkt->pkttype == PKT_SIGNATURE
1069             && (sig=k->pkt->pkt.signature)->sig_class >= 0x10
1070             && sig->sig_class <= 0x30
1071             && sig->keyid[0] == kid[0]
1072             && sig->keyid[1] == kid[1]
1073             && sig->version > 3 ) {
1074             /* okay this is a self-signature which can be used.
1075              * We use the latest self-signature.
1076              * FIXME: We should only use this if the signature is valid
1077              *        but this is time consuming - we must provide another
1078              *        way to handle this
1079              */
1080             const byte *p;
1081             u32 ed;
1082
1083             p = parse_sig_subpkt( sig->hashed_data, SIGSUBPKT_KEY_EXPIRE, NULL );
1084             ed = p? pk->timestamp + buffer_to_u32(p):0;
1085             /* use the latest self signature */
1086             if( sig->timestamp > sigdate ) {
1087                 pk->expiredate = ed;
1088                 orig_pk->expiredate = ed;
1089                 sigdate = sig->timestamp;
1090             }
1091             /* fixme: add usage etc. to pk */
1092         }
1093         else if( k->pkt->pkttype == PKT_PUBLIC_SUBKEY )
1094             break; /* stop here */
1095     }
1096 }
1097
1098
1099 /****************
1100  * merge all selfsignatures with the keys.
1101  */
1102 void
1103 merge_keys_and_selfsig( KBNODE keyblock )
1104 {
1105     PKT_public_key *pk = NULL;
1106     PKT_secret_key *sk = NULL;
1107     PKT_signature *sig;
1108     KBNODE k;
1109     u32 kid[2] = { 0, 0 };
1110     u32 sigdate = 0;
1111
1112     for(k=keyblock; k; k = k->next ) {
1113         if( k->pkt->pkttype == PKT_PUBLIC_KEY
1114             || k->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
1115             pk = k->pkt->pkt.public_key; sk = NULL;
1116             if( pk->version < 4 )
1117                 pk = NULL; /* not needed for old keys */
1118             else if( k->pkt->pkttype == PKT_PUBLIC_KEY )
1119                 keyid_from_pk( pk, kid );
1120             sigdate = 0;
1121         }
1122         else if( k->pkt->pkttype == PKT_SECRET_KEY
1123             || k->pkt->pkttype == PKT_SECRET_SUBKEY ) {
1124             pk = NULL; sk = k->pkt->pkt.secret_key;
1125             if( sk->version < 4 )
1126                 sk = NULL;
1127             else if( k->pkt->pkttype == PKT_SECRET_KEY )
1128                 keyid_from_sk( sk, kid );
1129             sigdate = 0;
1130         }
1131         else if( (pk || sk ) && k->pkt->pkttype == PKT_SIGNATURE
1132                  && (sig=k->pkt->pkt.signature)->sig_class >= 0x10
1133                  && sig->sig_class <= 0x30 && sig->version > 3
1134                  && sig->keyid[0] == kid[0] && sig->keyid[1] == kid[1] ) {
1135             /* okay this is a self-signature which can be used.
1136              * FIXME: We should only use this if the signature is valid
1137              *        but this is time consuming - we must provide another
1138              *        way to handle this
1139              */
1140             const byte *p;
1141             u32 ed;
1142
1143             p = parse_sig_subpkt( sig->hashed_data, SIGSUBPKT_KEY_EXPIRE, NULL );
1144             if( pk ) {
1145                 ed = p? pk->timestamp + buffer_to_u32(p):0;
1146                 if( sig->timestamp > sigdate ) {
1147                     pk->expiredate = ed;
1148                     sigdate = sig->timestamp;
1149                 }
1150             }
1151             else {
1152                 ed = p? sk->timestamp + buffer_to_u32(p):0;
1153                 if( sig->timestamp > sigdate ) {
1154                     sk->expiredate = ed;
1155                     sigdate = sig->timestamp;
1156                 }
1157             }
1158         }
1159     }
1160 }
1161
1162
1163 static KBNODE
1164 find_by_name( KBNODE keyblock, PKT_public_key *pk, const char *name,
1165               int mode, byte *namehash, int *use_namehash )
1166 {
1167     KBNODE k, kk;
1168
1169     for(k=keyblock; k; k = k->next ) {
1170         if( k->pkt->pkttype == PKT_USER_ID
1171             && !compare_name( k->pkt->pkt.user_id->name,
1172                               k->pkt->pkt.user_id->len, name, mode)) {
1173             /* we found a matching name, look for the key */
1174             for(kk=keyblock; kk; kk = kk->next ) {
1175                 if( (    kk->pkt->pkttype == PKT_PUBLIC_KEY
1176                       || kk->pkt->pkttype == PKT_PUBLIC_SUBKEY )
1177                     && ( !pk->pubkey_algo
1178                          || pk->pubkey_algo
1179                             == kk->pkt->pkt.public_key->pubkey_algo)
1180                     && ( !pk->pubkey_usage
1181                          || !check_pubkey_algo2(
1182                                kk->pkt->pkt.public_key->pubkey_algo,
1183                                                    pk->pubkey_usage ))
1184                   )
1185                     break;
1186             }
1187             if( kk ) {
1188                 u32 aki[2];
1189                 keyid_from_pk( kk->pkt->pkt.public_key, aki );
1190                 cache_user_id( k->pkt->pkt.user_id, aki );
1191                 rmd160_hash_buffer( namehash,
1192                                     k->pkt->pkt.user_id->name,
1193                                     k->pkt->pkt.user_id->len );
1194                 *use_namehash = 1;
1195                 return kk;
1196             }
1197             else if( is_RSA(pk->pubkey_algo) )
1198                 log_error("RSA key cannot be used in this version\n");
1199             else
1200                 log_error("No key for userid\n");
1201         }
1202     }
1203     return NULL;
1204 }
1205
1206 static KBNODE
1207 find_by_name_sk( KBNODE keyblock, PKT_secret_key *sk, const char *name,
1208                  int mode )
1209 {
1210     KBNODE k, kk;
1211
1212     for(k=keyblock; k; k = k->next ) {
1213         if( k->pkt->pkttype == PKT_USER_ID
1214             && !compare_name( k->pkt->pkt.user_id->name,
1215                               k->pkt->pkt.user_id->len, name, mode)) {
1216             /* we found a matching name, look for the key */
1217             for(kk=keyblock; kk; kk = kk->next ) {
1218                 if( (    kk->pkt->pkttype == PKT_SECRET_KEY
1219                       || kk->pkt->pkttype == PKT_SECRET_SUBKEY )
1220                     && ( !sk->pubkey_algo
1221                          || sk->pubkey_algo
1222                             == kk->pkt->pkt.secret_key->pubkey_algo)
1223                     && ( !sk->pubkey_usage
1224                          || !check_pubkey_algo2(
1225                                kk->pkt->pkt.secret_key->pubkey_algo,
1226                                                    sk->pubkey_usage ))
1227                   )
1228                     break;
1229             }
1230             if( kk ) {
1231                 u32 aki[2];
1232                 keyid_from_sk( kk->pkt->pkt.secret_key, aki );
1233                 cache_user_id( k->pkt->pkt.user_id, aki );
1234                 return kk;
1235             }
1236             else if( is_RSA(sk->pubkey_algo) )
1237                 log_error("RSA key cannot be used in this version\n");
1238             else
1239                 log_error("No key for userid\n");
1240         }
1241     }
1242     return NULL;
1243 }
1244
1245
1246 static KBNODE
1247 find_by_keyid( KBNODE keyblock, PKT_public_key *pk, u32 *keyid, int mode )
1248 {
1249     KBNODE k;
1250
1251     if( DBG_CACHE )
1252         log_debug("lookup keyid=%08lx%08lx req_algo=%d mode=%d\n",
1253                    (ulong)keyid[0], (ulong)keyid[1], pk->pubkey_algo, mode );
1254
1255     for(k=keyblock; k; k = k->next ) {
1256         if(    k->pkt->pkttype == PKT_PUBLIC_KEY
1257             || k->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
1258             u32 aki[2];
1259             keyid_from_pk( k->pkt->pkt.public_key, aki );
1260             if( DBG_CACHE )
1261                 log_debug("         aki=%08lx%08lx algo=%d\n",
1262                                 (ulong)aki[0], (ulong)aki[1],
1263                                  k->pkt->pkt.public_key->pubkey_algo    );
1264
1265             if( aki[1] == keyid[1]
1266                 && ( mode == 10 || aki[0] == keyid[0] )
1267                 && ( !pk->pubkey_algo
1268                      || pk->pubkey_algo
1269                         == k->pkt->pkt.public_key->pubkey_algo) ){
1270                 KBNODE kk;
1271                 /* cache the userid */
1272                 for(kk=keyblock; kk; kk = kk->next )
1273                     if( kk->pkt->pkttype == PKT_USER_ID )
1274                         break;
1275                 if( kk )
1276                     cache_user_id( kk->pkt->pkt.user_id, aki );
1277                 else
1278                     log_error("No userid for key\n");
1279                 return k; /* found */
1280             }
1281         }
1282     }
1283     return NULL;
1284 }
1285
1286 static KBNODE
1287 find_by_keyid_sk( KBNODE keyblock, PKT_secret_key *sk, u32 *keyid, int mode )
1288 {
1289     KBNODE k;
1290
1291     if( DBG_CACHE )
1292         log_debug("lookup_sk keyid=%08lx%08lx req_algo=%d mode=%d\n",
1293                    (ulong)keyid[0], (ulong)keyid[1], sk->pubkey_algo, mode );
1294
1295     for(k=keyblock; k; k = k->next ) {
1296         if(    k->pkt->pkttype == PKT_SECRET_KEY
1297             || k->pkt->pkttype == PKT_SECRET_SUBKEY ) {
1298             u32 aki[2];
1299             keyid_from_sk( k->pkt->pkt.secret_key, aki );
1300             if( DBG_CACHE )
1301                 log_debug("         aki=%08lx%08lx algo=%d\n",
1302                                 (ulong)aki[0], (ulong)aki[1],
1303                                  k->pkt->pkt.secret_key->pubkey_algo    );
1304
1305             if( aki[1] == keyid[1]
1306                 && ( mode == 10 || aki[0] == keyid[0] )
1307                 && ( !sk->pubkey_algo
1308                      || sk->pubkey_algo
1309                         == k->pkt->pkt.secret_key->pubkey_algo) ){
1310                 KBNODE kk;
1311                 /* cache the userid */
1312                 for(kk=keyblock; kk; kk = kk->next )
1313                     if( kk->pkt->pkttype == PKT_USER_ID )
1314                         break;
1315                 if( kk )
1316                     cache_user_id( kk->pkt->pkt.user_id, aki );
1317                 else
1318                     log_error("No userid for key\n");
1319                 return k; /* found */
1320             }
1321         }
1322     }
1323     return NULL;
1324 }
1325
1326
1327 static KBNODE
1328 find_first( KBNODE keyblock, PKT_public_key *pk )
1329 {
1330     KBNODE k;
1331
1332     for(k=keyblock; k; k = k->next ) {
1333         if(    k->pkt->pkttype == PKT_PUBLIC_KEY
1334             || k->pkt->pkttype == PKT_PUBLIC_SUBKEY )
1335         {
1336             if( !pk->pubkey_algo
1337                 || pk->pubkey_algo == k->pkt->pkt.public_key->pubkey_algo )
1338                 return k;
1339         }
1340     }
1341     return NULL;
1342 }
1343
1344 static KBNODE
1345 find_first_sk( KBNODE keyblock, PKT_secret_key *sk )
1346 {
1347     KBNODE k;
1348
1349     for(k=keyblock; k; k = k->next ) {
1350         if(    k->pkt->pkttype == PKT_SECRET_KEY
1351             || k->pkt->pkttype == PKT_SECRET_SUBKEY )
1352         {
1353             if( !sk->pubkey_algo
1354                 || sk->pubkey_algo == k->pkt->pkt.secret_key->pubkey_algo )
1355                 return k;
1356         }
1357     }
1358     return NULL;
1359 }
1360
1361
1362 static KBNODE
1363 find_by_fpr( KBNODE keyblock, PKT_public_key *pk, const char *name, int mode )
1364 {
1365     KBNODE k;
1366
1367     for(k=keyblock; k; k = k->next ) {
1368         if(    k->pkt->pkttype == PKT_PUBLIC_KEY
1369             || k->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
1370             byte afp[MAX_FINGERPRINT_LEN];
1371             size_t an;
1372
1373             fingerprint_from_pk(k->pkt->pkt.public_key, afp, &an );
1374
1375             if( DBG_CACHE ) {
1376                 u32 aki[2];
1377                 keyid_from_pk( k->pkt->pkt.public_key, aki );
1378                 log_debug("         aki=%08lx%08lx algo=%d mode=%d an=%u\n",
1379                                 (ulong)aki[0], (ulong)aki[1],
1380                         k->pkt->pkt.public_key->pubkey_algo, mode, an );
1381             }
1382
1383             if( an == mode
1384                 && !memcmp( afp, name, an)
1385                 && ( !pk->pubkey_algo
1386                      || pk->pubkey_algo == k->pkt->pkt.public_key->pubkey_algo) )
1387                 return k;
1388         }
1389     }
1390     return NULL;
1391 }
1392
1393 static KBNODE
1394 find_by_fpr_sk( KBNODE keyblock, PKT_secret_key *sk,
1395                                  const char *name, int mode )
1396 {
1397     KBNODE k;
1398
1399     for(k=keyblock; k; k = k->next ) {
1400         if(    k->pkt->pkttype == PKT_SECRET_KEY
1401             || k->pkt->pkttype == PKT_SECRET_SUBKEY ) {
1402             byte afp[MAX_FINGERPRINT_LEN];
1403             size_t an;
1404
1405             fingerprint_from_sk(k->pkt->pkt.secret_key, afp, &an );
1406
1407             if( DBG_CACHE ) {
1408                 u32 aki[2];
1409                 keyid_from_sk( k->pkt->pkt.secret_key, aki );
1410                 log_debug("         aki=%08lx%08lx algo=%d mode=%d an=%u\n",
1411                                 (ulong)aki[0], (ulong)aki[1],
1412                         k->pkt->pkt.secret_key->pubkey_algo, mode, an );
1413             }
1414
1415             if( an == mode
1416                 && !memcmp( afp, name, an)
1417                 && ( !sk->pubkey_algo
1418                      || sk->pubkey_algo == k->pkt->pkt.secret_key->pubkey_algo) )
1419                 return k;
1420         }
1421     }
1422     return NULL;
1423 }
1424
1425
1426 static void
1427 finish_lookup( KBNODE keyblock, PKT_public_key *pk, KBNODE k, byte *namehash,
1428                                                int use_namehash, int primary )
1429 {
1430     assert(    k->pkt->pkttype == PKT_PUBLIC_KEY
1431             || k->pkt->pkttype == PKT_PUBLIC_SUBKEY );
1432     assert( keyblock->pkt->pkttype == PKT_PUBLIC_KEY );
1433     if( primary && !pk->pubkey_usage ) {
1434         copy_public_key_new_namehash( pk, keyblock->pkt->pkt.public_key,
1435                                       use_namehash? namehash:NULL);
1436         merge_one_pk_and_selfsig( keyblock, keyblock, pk );
1437     }
1438     else {
1439         if( primary && pk->pubkey_usage
1440             && check_pubkey_algo2( k->pkt->pkt.public_key->pubkey_algo,
1441                        pk->pubkey_usage ) == G10ERR_WR_PUBKEY_ALGO ) {
1442             /* if the usage is not correct, try to use a subkey */
1443             KBNODE save_k = k;
1444
1445             k = NULL;
1446             /* kludge for pgp 5: which doesn't accept type 20:
1447              * try to use a type 16 subkey instead */
1448             if( pk->pubkey_usage == PUBKEY_USAGE_ENC ) {
1449                 for( k = save_k; k; k = k->next ) {
1450                     if( k->pkt->pkttype == PKT_PUBLIC_SUBKEY
1451                         && k->pkt->pkt.public_key->pubkey_algo
1452                             == PUBKEY_ALGO_ELGAMAL_E
1453                         && !check_pubkey_algo2(
1454                                 k->pkt->pkt.public_key->pubkey_algo,
1455                                                  pk->pubkey_usage ) )
1456                         break;
1457                 }
1458             }
1459
1460             if( !k ) {
1461                 for(k = save_k ; k; k = k->next ) {
1462                     if( k->pkt->pkttype == PKT_PUBLIC_SUBKEY
1463                         && !check_pubkey_algo2(
1464                                 k->pkt->pkt.public_key->pubkey_algo,
1465                                                  pk->pubkey_usage ) )
1466                         break;
1467                 }
1468             }
1469             if( !k )
1470                 k = save_k;
1471             else
1472                 log_info(_("using secondary key %08lX "
1473                            "instead of primary key %08lX\n"),
1474                       (ulong)keyid_from_pk( k->pkt->pkt.public_key, NULL),
1475                       (ulong)keyid_from_pk( save_k->pkt->pkt.public_key, NULL)
1476                         );
1477         }
1478
1479         copy_public_key_new_namehash( pk, k->pkt->pkt.public_key,
1480                                       use_namehash? namehash:NULL);
1481         merge_one_pk_and_selfsig( keyblock, k, pk );
1482     }
1483 }
1484
1485 static void
1486 finish_lookup_sk( KBNODE keyblock, PKT_secret_key *sk, KBNODE k, int primary )
1487 {
1488     assert(    k->pkt->pkttype == PKT_SECRET_KEY
1489             || k->pkt->pkttype == PKT_SECRET_SUBKEY );
1490     assert( keyblock->pkt->pkttype == PKT_SECRET_KEY );
1491     if( primary && !sk->pubkey_usage ) {
1492         copy_secret_key( sk, keyblock->pkt->pkt.secret_key );
1493     }
1494     else {
1495         if( primary && sk->pubkey_usage
1496             && check_pubkey_algo2( k->pkt->pkt.secret_key->pubkey_algo,
1497                        sk->pubkey_usage ) == G10ERR_WR_PUBKEY_ALGO ) {
1498             /* if the usage is not correct, try to use a subkey */
1499             KBNODE save_k = k;
1500
1501             k = NULL;
1502             /* kludge for pgp 5: which doesn't accept type 20:
1503              * try to use a type 16 subkey instead */
1504             if( sk->pubkey_usage == PUBKEY_USAGE_ENC ) {
1505                 for( k = save_k; k; k = k->next ) {
1506                     if( k->pkt->pkttype == PKT_SECRET_SUBKEY
1507                         && k->pkt->pkt.secret_key->pubkey_algo
1508                             == PUBKEY_ALGO_ELGAMAL_E
1509                         && !check_pubkey_algo2(
1510                                 k->pkt->pkt.secret_key->pubkey_algo,
1511                                                  sk->pubkey_usage ) )
1512                         break;
1513                 }
1514             }
1515
1516             if( !k ) {
1517                 for(k = save_k ; k; k = k->next ) {
1518                     if( k->pkt->pkttype == PKT_SECRET_SUBKEY
1519                         && !check_pubkey_algo2(
1520                                 k->pkt->pkt.secret_key->pubkey_algo,
1521                                                  sk->pubkey_usage ) )
1522                         break;
1523                 }
1524             }
1525             if( !k )
1526                 k = save_k;
1527             else
1528                 log_info(_("using secondary key %08lX "
1529                            "instead of primary key %08lX\n"),
1530                       (ulong)keyid_from_sk( k->pkt->pkt.secret_key, NULL),
1531                       (ulong)keyid_from_sk( save_k->pkt->pkt.secret_key, NULL)
1532                         );
1533         }
1534
1535         copy_secret_key( sk, k->pkt->pkt.secret_key );
1536     }
1537 }
1538
1539
1540 /****** old code from lookup_read ******/
1541 #if 0 /* can't use it anymore - invent a more general approach */
1542     /* try the quick functions */
1543     if( !ctx->count ) {
1544         k = NULL;
1545         switch( ctx->mode ) {
1546           case 10:
1547           case 11:
1548             rc = locate_keyblock_by_keyid( &ctx->kbpos, ctx->keyid,
1549                                                         ctx->mode==10, 0 );
1550             if( !rc )
1551                 rc = read_keyblock( &ctx->kbpos, &ctx->keyblock );
1552             if( !rc )
1553                 k = find_by_keyid( ctx->keyblock, pk, ctx->keyid, ctx->mode );
1554             break;
1555
1556           case 16:
1557           case 20:
1558             rc = locate_keyblock_by_fpr( &ctx->kbpos, ctx->name, ctx->mode, 0 );
1559             if( !rc )
1560                 rc = read_keyblock( &ctx->kbpos, &ctx->keyblock );
1561             if( !rc )
1562                 k = find_by_fpr( ctx->keyblock, pk, ctx->name, ctx->mode );
1563             break;
1564
1565           default: rc = G10ERR_UNSUPPORTED;
1566         }
1567         if( !rc ) {
1568             if( !k ) {
1569                 log_error("lookup: key has been located but was not found\n");
1570                 rc = G10ERR_INV_KEYRING;
1571             }
1572             else
1573                 finish_lookup( ctx->keyblock, pk, k, namehash, 0, ctx->primary );
1574         }
1575     }
1576     else
1577         rc = G10ERR_UNSUPPORTED;
1578
1579     /* if this was not possible, loop over all keyblocks
1580      * fixme: If one of the resources in the quick functions above
1581      *        works, but the key was not found, we will not find it
1582      *        in the other resources */
1583     if( rc == G10ERR_UNSUPPORTED ) {
1584     }
1585 #endif
1586
1587
1588 static int
1589 lookup_pk( GETKEY_CTX ctx, PKT_public_key *pk, KBNODE *ret_keyblock )
1590 {
1591     int rc;
1592     KBNODE k;
1593     int oldmode = set_packet_list_mode(0);
1594     byte namehash[20];
1595     int use_namehash=0;
1596
1597     if( !ctx->count ) /* first time */
1598         rc = enum_keyblocks( 0, &ctx->kbpos, &ctx->keyblock );
1599     else
1600         rc = 0;
1601     if( !rc ) {
1602         while( !(rc = enum_keyblocks( 1, &ctx->kbpos, &ctx->keyblock )) ) {
1603             int n;
1604             getkey_item_t *item;
1605             /* fixme: we don't enum the complete keyblock, but
1606              * use the first match and then continue with the next keyblock
1607              */
1608             /* loop over all the user ids we want to look for */
1609             item = ctx->items;
1610             for(n=0; n < ctx->nitems; n++, item++ ) {
1611                 if( item->mode < 10 )
1612                     k = find_by_name( ctx->keyblock, pk,
1613                                       item->name, item->mode,
1614                                       namehash, &use_namehash );
1615                 else if( item->mode == 10 || item->mode == 11 )
1616                     k = find_by_keyid( ctx->keyblock, pk,
1617                                        item->keyid, item->mode );
1618                 else if( item->mode == 15 )
1619                     k = find_first( ctx->keyblock, pk );
1620                 else if( item->mode == 16 || item->mode == 20 )
1621                     k = find_by_fpr( ctx->keyblock, pk,
1622                                      item->fprint, item->mode );
1623                 else
1624                     BUG();
1625                 if( k ) {
1626                     finish_lookup( ctx->keyblock, pk, k, namehash,
1627                                                  use_namehash, ctx->primary );
1628                     goto found;
1629                 }
1630             }
1631             release_kbnode( ctx->keyblock );
1632             ctx->keyblock = NULL;
1633         }
1634       found: ;
1635     }
1636     if( rc && rc != -1 )
1637         log_error("enum_keyblocks failed: %s\n", g10_errstr(rc));
1638
1639     if( !rc ) {
1640         if( ret_keyblock ) {
1641             *ret_keyblock = ctx->keyblock;
1642             ctx->keyblock = NULL;
1643         }
1644     }
1645     else if( rc == -1 )
1646         rc = G10ERR_NO_PUBKEY;
1647
1648     release_kbnode( ctx->keyblock );
1649     ctx->keyblock = NULL;
1650     set_packet_list_mode(oldmode);
1651   #if 0
1652     if( opt.debug & DBG_MEMSTAT_VALUE ) {
1653         static int initialized;
1654
1655         if( !initialized ) {
1656             initialized = 1;
1657             atexit( print_stats );
1658         }
1659
1660         assert( ctx->mode < DIM(lkup_stats) );
1661         lkup_stats[ctx->mode].any = 1;
1662         if( !rc )
1663             lkup_stats[ctx->mode].okay_count++;
1664         else if ( rc == G10ERR_NO_PUBKEY )
1665             lkup_stats[ctx->mode].nokey_count++;
1666         else
1667             lkup_stats[ctx->mode].error_count++;
1668     }
1669    #endif
1670
1671     ctx->last_rc = rc;
1672     ctx->count++;
1673     return rc;
1674 }
1675
1676
1677
1678 static int
1679 lookup_sk( GETKEY_CTX ctx, PKT_secret_key *sk, KBNODE *ret_keyblock )
1680 {
1681     int rc;
1682     KBNODE k;
1683     int oldmode = set_packet_list_mode(0);
1684
1685     if( !ctx->count ) /* first time */
1686         rc = enum_keyblocks( 5, &ctx->kbpos, &ctx->keyblock );
1687     else
1688         rc = 0;
1689     if( !rc ) {
1690         while( !(rc = enum_keyblocks( 1, &ctx->kbpos, &ctx->keyblock )) ) {
1691             int n;
1692             getkey_item_t *item;
1693             /* fixme: we don't enum the complete keyblock, but
1694              * use the first match and then continue with the next keyblock
1695              */
1696             /* loop over all the user ids we want to look for */
1697             item = ctx->items;
1698             for(n=0; n < ctx->nitems; n++, item++ ) {
1699                 if( item->mode < 10 )
1700                     k = find_by_name_sk( ctx->keyblock, sk,
1701                                          item->name, item->mode );
1702                 else if( item->mode == 10 || item->mode == 11 )
1703                     k = find_by_keyid_sk( ctx->keyblock, sk,
1704                                           item->keyid, item->mode );
1705                 else if( item->mode == 15 )
1706                     k = find_first_sk( ctx->keyblock, sk );
1707                 else if( item->mode == 16 || item->mode == 20 )
1708                     k = find_by_fpr_sk( ctx->keyblock, sk,
1709                                         item->fprint, item->mode );
1710                 else
1711                     BUG();
1712                 if( k ) {
1713                     finish_lookup_sk( ctx->keyblock, sk, k, ctx->primary );
1714                     goto found;
1715                 }
1716             }
1717             release_kbnode( ctx->keyblock );
1718             ctx->keyblock = NULL;
1719         }
1720       found: ;
1721     }
1722     if( rc && rc != -1 )
1723         log_error("enum_keyblocks failed: %s\n", g10_errstr(rc));
1724
1725     if( !rc ) {
1726         if( ret_keyblock ) {
1727             *ret_keyblock = ctx->keyblock;
1728             ctx->keyblock = NULL;
1729         }
1730     }
1731     else if( rc == -1 )
1732         rc = G10ERR_NO_PUBKEY;
1733
1734     release_kbnode( ctx->keyblock );
1735     ctx->keyblock = NULL;
1736     set_packet_list_mode(oldmode);
1737
1738     ctx->last_rc = rc;
1739     ctx->count++;
1740     return rc;
1741 }
1742
1743
1744 #if 0
1745 OLD/************
1746 OLD * Ditto for secret keys WORK!!!!!!
1747 OLD */
1748 OLDstatic int
1749 OLDlookup_sk( PKT_secret_key *sk, int mode,  u32 *keyid, const char *name,
1750 OLD           int primary )
1751 OLD{
1752 OLD    int rc;
1753 OLD    KBNODE keyblock = NULL;
1754 OLD    KBPOS kbpos;
1755 OLD    int oldmode = set_packet_list_mode(0);
1756 OLD
1757 OLD    rc = enum_keyblocks( 5 /* open secret */, &kbpos, &keyblock );
1758 OLD    if( rc ) {
1759 OLD        if( rc == -1 )
1760 OLD            rc = G10ERR_NO_SECKEY;
1761 OLD        else if( rc )
1762 OLD            log_error("enum_keyblocks(open secret) failed: %s\n", g10_errstr(rc) );
1763 OLD        goto leave;
1764 OLD    }
1765 OLD
1766 OLD    while( !(rc = enum_keyblocks( 1, &kbpos, &keyblock )) ) {
1767 OLD        KBNODE k, kk;
1768 OLD        if( mode < 10 ) { /* name lookup */
1769 OLD            for(k=keyblock; k; k = k->next ) {
1770 OLD                if( k->pkt->pkttype == PKT_USER_ID
1771 OLD                    && !compare_name( k->pkt->pkt.user_id->name,
1772 OLD                                      k->pkt->pkt.user_id->len, name, mode)) {
1773 OLD                    /* we found a matching name, look for the key */
1774 OLD                    for(kk=keyblock; kk; kk = kk->next ) {
1775 OLD                        if( (    kk->pkt->pkttype == PKT_SECRET_KEY
1776 OLD                              || kk->pkt->pkttype == PKT_SECRET_SUBKEY )
1777 OLD                            && ( !sk->pubkey_algo
1778 OLD                                 || sk->pubkey_algo
1779 OLD                                    == kk->pkt->pkt.secret_key->pubkey_algo)
1780 OLD                            && ( !sk->pubkey_usage
1781 OLD                                 || !check_pubkey_algo2(
1782 OLD                                       kk->pkt->pkt.secret_key->pubkey_algo,
1783 OLD                                                           sk->pubkey_usage ))
1784 OLD                          )
1785 OLD                            break;
1786 OLD                    }
1787 OLD                    if( kk ) {
1788 OLD                        u32 aki[2];
1789 OLD                        keyid_from_sk( kk->pkt->pkt.secret_key, aki );
1790 OLD                        cache_user_id( k->pkt->pkt.user_id, aki );
1791 OLD                        k = kk;
1792 OLD                        break;
1793 OLD                    }
1794 OLD                    else
1795 OLD                        log_error("No key for userid (in sk)\n");
1796 OLD                }
1797 OLD            }
1798 OLD        }
1799 OLD        else { /* keyid or fingerprint lookup */
1800 OLD            if( DBG_CACHE && (mode== 10 || mode==11) ) {
1801 OLD                log_debug("lookup_sk keyid=%08lx%08lx req_algo=%d mode=%d\n",
1802 OLD                                (ulong)keyid[0], (ulong)keyid[1],
1803 OLD                                 sk->pubkey_algo, mode );
1804 OLD            }
1805 OLD            for(k=keyblock; k; k = k->next ) {
1806 OLD                if(    k->pkt->pkttype == PKT_SECRET_KEY
1807 OLD                    || k->pkt->pkttype == PKT_SECRET_SUBKEY ) {
1808 OLD                    if( mode == 10 || mode == 11 ) {
1809 OLD                        u32 aki[2];
1810 OLD                        keyid_from_sk( k->pkt->pkt.secret_key, aki );
1811 OLD                        if( DBG_CACHE ) {
1812 OLD                            log_debug("             aki=%08lx%08lx algo=%d\n",
1813 OLD                                            (ulong)aki[0], (ulong)aki[1],
1814 OLD                                    k->pkt->pkt.secret_key->pubkey_algo    );
1815 OLD                        }
1816 OLD                        if( aki[1] == keyid[1]
1817 OLD                            && ( mode == 10 || aki[0] == keyid[0] )
1818 OLD                            && ( !sk->pubkey_algo
1819 OLD                                 || sk->pubkey_algo
1820 OLD                                    == k->pkt->pkt.secret_key->pubkey_algo) ){
1821 OLD                            /* cache the userid */
1822 OLD                            for(kk=keyblock; kk; kk = kk->next )
1823 OLD                                if( kk->pkt->pkttype == PKT_USER_ID )
1824 OLD                                    break;
1825 OLD                            if( kk )
1826 OLD                                cache_user_id( kk->pkt->pkt.user_id, aki );
1827 OLD                            else
1828 OLD                                log_error("No userid for key\n");
1829 OLD                            break; /* found */
1830 OLD                        }
1831 OLD                    }
1832 OLD                    else if( mode == 15 ) { /* get the first key */
1833 OLD                        if( !sk->pubkey_algo
1834 OLD                            || sk->pubkey_algo
1835 OLD                                  == k->pkt->pkt.secret_key->pubkey_algo )
1836 OLD                            break;
1837 OLD                    }
1838 OLD                    else if( mode == 16 || mode == 20 ) {
1839 OLD                        size_t an;
1840 OLD                        byte afp[MAX_FINGERPRINT_LEN];
1841 OLD
1842 OLD                        fingerprint_from_sk(k->pkt->pkt.secret_key, afp, &an );
1843 OLD                        if( an == mode && !memcmp( afp, name, an)
1844 OLD                            && ( !sk->pubkey_algo
1845 OLD                                 || sk->pubkey_algo
1846 OLD                                    == k->pkt->pkt.secret_key->pubkey_algo) ) {
1847 OLD                            break;
1848 OLD                        }
1849 OLD                    }
1850 OLD                    else
1851 OLD                        BUG();
1852 OLD                } /* end compare secret keys */
1853 OLD            }
1854 OLD        }
1855 OLD        if( k ) { /* found */
1856 OLD            assert(    k->pkt->pkttype == PKT_SECRET_KEY
1857 OLD                    || k->pkt->pkttype == PKT_SECRET_SUBKEY );
1858 OLD            assert( keyblock->pkt->pkttype == PKT_SECRET_KEY );
1859 OLD            if( primary && !sk->pubkey_usage )
1860 OLD                copy_secret_key( sk, keyblock->pkt->pkt.secret_key );
1861 OLD            else
1862 OLD                copy_secret_key( sk, k->pkt->pkt.secret_key );
1863 OLD            break; /* enumeration */
1864 OLD        }
1865 OLD        release_kbnode( keyblock );
1866 OLD        keyblock = NULL;
1867 OLD    }
1868 OLD    if( rc == -1 )
1869 OLD        rc = G10ERR_NO_SECKEY;
1870 OLD    else if( rc )
1871 OLD        log_error("enum_keyblocks(read) failed: %s\n", g10_errstr(rc));
1872 OLD
1873 OLD  leave:
1874 OLD    enum_keyblocks( 2, &kbpos, &keyblock ); /* close */
1875 OLD    release_kbnode( keyblock );
1876 OLD    set_packet_list_mode(oldmode);
1877 OLD    return rc;
1878 OLD}
1879 #endif
1880
1881
1882 /****************
1883  * fixme: replace by the generic function
1884  *
1885  * Enumerate all primary secret keys.  Caller must use these procedure:
1886  *  1) create a void pointer and initialize it to NULL
1887  *  2) pass this void pointer by reference to this function
1888  *     and provide space for the secret key (pass a buffer for sk)
1889  *  3) call this function as long as it does not return -1
1890  *     to indicate EOF.
1891  *  4) Always call this function a last time with SK set to NULL,
1892  *     so that can free it's context.
1893  *
1894  *
1895  */
1896 int
1897 enum_secret_keys( void **context, PKT_secret_key *sk, int with_subkeys )
1898 {
1899     int rc=0;
1900     PACKET pkt;
1901     int save_mode;
1902     struct {
1903         int eof;
1904         int sequence;
1905         const char *name;
1906         IOBUF iobuf;
1907     } *c = *context;
1908
1909
1910     if( !c ) { /* make a new context */
1911         c = m_alloc_clear( sizeof *c );
1912         *context = c;
1913         c->sequence = 0;
1914         c->name = enum_keyblock_resources( &c->sequence, 1 );
1915     }
1916
1917     if( !sk ) { /* free the context */
1918         if( c->iobuf )
1919             iobuf_close(c->iobuf);
1920         m_free( c );
1921         *context = NULL;
1922         return 0;
1923     }
1924
1925     if( c->eof )
1926         return -1;
1927
1928     /* FIXME: This assumes a plain keyring file */
1929     for( ; c->name; c->name = enum_keyblock_resources( &c->sequence, 1 ) ) {
1930         if( !c->iobuf ) {
1931             if( !(c->iobuf = iobuf_open( c->name ) ) ) {
1932                 log_error("enum_secret_keys: can't open `%s'\n", c->name );
1933                 continue; /* try next file */
1934             }
1935         }
1936
1937         save_mode = set_packet_list_mode(0);
1938         init_packet(&pkt);
1939         while( (rc=parse_packet(c->iobuf, &pkt)) != -1 ) {
1940             if( rc )
1941                 ; /* e.g. unknown packet */
1942             else if( pkt.pkttype == PKT_SECRET_KEY
1943                      || ( with_subkeys && pkt.pkttype == PKT_SECRET_SUBKEY ) ) {
1944                 copy_secret_key( sk, pkt.pkt.secret_key );
1945                 set_packet_list_mode(save_mode);
1946                 return 0; /* found */
1947             }
1948             free_packet(&pkt);
1949         }
1950         set_packet_list_mode(save_mode);
1951         iobuf_close(c->iobuf); c->iobuf = NULL;
1952     }
1953     c->eof = 1;
1954     return -1;
1955 }
1956
1957
1958 /****************
1959  * Return a string with a printable representation of the user_id.
1960  * this string must be freed by m_free.
1961  */
1962 char*
1963 get_user_id_string( u32 *keyid )
1964 {
1965     user_id_db_t r;
1966     char *p;
1967     int pass=0;
1968     /* try it two times; second pass reads from key resources */
1969     do {
1970         for(r=user_id_db; r; r = r->next )
1971             if( r->keyid[0] == keyid[0] && r->keyid[1] == keyid[1] ) {
1972                 p = m_alloc( r->len + 10 );
1973                 sprintf(p, "%08lX %.*s", (ulong)keyid[1], r->len, r->name );
1974                 return p;
1975             }
1976     } while( ++pass < 2 && !get_pubkey( NULL, keyid ) );
1977     p = m_alloc( 15 );
1978     sprintf(p, "%08lX [?]", (ulong)keyid[1] );
1979     return p;
1980 }
1981
1982 char*
1983 get_long_user_id_string( u32 *keyid )
1984 {
1985     user_id_db_t r;
1986     char *p;
1987     int pass=0;
1988     /* try it two times; second pass reads from key resources */
1989     do {
1990         for(r=user_id_db; r; r = r->next )
1991             if( r->keyid[0] == keyid[0] && r->keyid[1] == keyid[1] ) {
1992                 p = m_alloc( r->len + 20 );
1993                 sprintf(p, "%08lX%08lX %.*s",
1994                           (ulong)keyid[0], (ulong)keyid[1], r->len, r->name );
1995                 return p;
1996             }
1997     } while( ++pass < 2 && !get_pubkey( NULL, keyid ) );
1998     p = m_alloc( 25 );
1999     sprintf(p, "%08lX%08lX [?]", (ulong)keyid[0], (ulong)keyid[1] );
2000     return p;
2001 }
2002
2003 char*
2004 get_user_id( u32 *keyid, size_t *rn )
2005 {
2006     user_id_db_t r;
2007     char *p;
2008     int pass=0;
2009     /* try it two times; second pass reads from key resources */
2010     do {
2011         for(r=user_id_db; r; r = r->next )
2012             if( r->keyid[0] == keyid[0] && r->keyid[1] == keyid[1] ) {
2013                 p = m_alloc( r->len );
2014                 memcpy(p, r->name, r->len );
2015                 *rn = r->len;
2016                 return p;
2017             }
2018     } while( ++pass < 2 && !get_pubkey( NULL, keyid ) );
2019     p = m_alloc( 19 );
2020     memcpy(p, "[User id not found]", 19 );
2021     *rn = 19;
2022     return p;
2023 }
2024
2025