See ChangeLog: Fri Feb 19 15:49:15 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 KBNODE
368 get_pubkeyblock( u32 *keyid )
369 {
370     PKT_public_key *pk = m_alloc_clear( sizeof *pk );
371     struct getkey_ctx_s ctx;
372     int rc = 0;
373     KBNODE keyblock = NULL;
374
375     memset( &ctx, 0, sizeof ctx );
376     ctx.not_allocated = 1;
377     ctx.nitems = 1;
378     ctx.items[0].mode = 11;
379     ctx.items[0].keyid[0] = keyid[0];
380     ctx.items[0].keyid[1] = keyid[1];
381     rc = lookup_pk( &ctx, pk, &keyblock );
382     free_public_key(pk);
383     get_pubkey_end( &ctx );
384
385     return rc ? NULL : keyblock;
386 }
387
388
389
390
391 /****************
392  * Get a secret key and store it into sk
393  */
394 int
395 get_seckey( PKT_secret_key *sk, u32 *keyid )
396 {
397     int rc;
398     struct getkey_ctx_s ctx;
399
400     memset( &ctx, 0, sizeof ctx );
401     ctx.not_allocated = 1;
402     ctx.nitems = 1;
403     ctx.items[0].mode = 11;
404     ctx.items[0].keyid[0] = keyid[0];
405     ctx.items[0].keyid[1] = keyid[1];
406     rc = lookup_sk( &ctx, sk, NULL );
407     get_seckey_end( &ctx );
408     if( !rc ) {
409         /* check the secret key (this may prompt for a passprase to
410          * unlock the secret key
411          */
412         rc = check_secret_key( sk, 0 );
413     }
414
415     return rc;
416 }
417
418
419 /****************
420  * Get the primary secret key and store it into sk
421  * Note: This function does not unprotect the key!
422  */
423 int
424 get_primary_seckey( PKT_secret_key *sk, u32 *keyid )
425 {
426     struct getkey_ctx_s ctx;
427     int rc;
428
429     memset( &ctx, 0, sizeof ctx );
430     ctx.not_allocated = 1;
431     ctx.primary = 1;
432     ctx.nitems = 1;
433     ctx.items[0].mode = 11;
434     ctx.items[0].keyid[0] = keyid[0];
435     ctx.items[0].keyid[1] = keyid[1];
436     rc = lookup_sk( &ctx, sk, NULL );
437     get_seckey_end( &ctx );
438     return rc;
439 }
440
441
442
443 /****************
444  * Check whether the secret key is available
445  * Returns: 0 := key is available
446  *          G10ERR_NO_SECKEY := not availabe
447  */
448 int
449 seckey_available( u32 *keyid )
450 {
451     int rc;
452     struct getkey_ctx_s ctx;
453     PKT_secret_key *sk;
454
455     sk = m_alloc_clear( sizeof *sk );
456     memset( &ctx, 0, sizeof ctx );
457     ctx.not_allocated = 1;
458     ctx.nitems = 1;
459     ctx.items[0].mode = 11;
460     ctx.items[0].keyid[0] = keyid[0];
461     ctx.items[0].keyid[1] = keyid[1];
462     rc = lookup_sk( &ctx, sk, NULL );
463     get_seckey_end( &ctx );
464     free_secret_key( sk );
465     return rc;
466 }
467
468
469
470 static int
471 hextobyte( const byte *s )
472 {
473     int c;
474
475     if( *s >= '0' && *s <= '9' )
476         c = 16 * (*s - '0');
477     else if( *s >= 'A' && *s <= 'F' )
478         c = 16 * (10 + *s - 'A');
479     else if( *s >= 'a' && *s <= 'f' )
480         c = 16 * (10 + *s - 'a');
481     else
482         return -1;
483     s++;
484     if( *s >= '0' && *s <= '9' )
485         c += *s - '0';
486     else if( *s >= 'A' && *s <= 'F' )
487         c += 10 + *s - 'A';
488     else if( *s >= 'a' && *s <= 'f' )
489         c += 10 + *s - 'a';
490     else
491         return -1;
492     return c;
493 }
494
495
496
497 /****************
498  * Return the type of the user id:
499  *
500  *  0 = Invalid user ID
501  *  1 = exact match
502  *  2 = match a substring
503  *  3 = match an email address
504  *  4 = match a substring of an email address
505  *  5 = match an email address, but compare from end
506  *  6 = word match mode
507  * 10 = it is a short KEYID (don't care about keyid[0])
508  * 11 = it is a long  KEYID
509  * 16 = it is a 16 byte fingerprint
510  * 20 = it is a 20 byte fingerprint
511  *
512  * if fprint is not NULL, it should be an array of at least 20 bytes.
513  *
514  * Rules used:
515  * - If the username starts with 8,9,16 or 17 hex-digits (the first one
516  *   must be in the range 0..9), this is considered a keyid; depending
517  *   on the length a short or complete one.
518  * - If the username starts with 32,33,40 or 41 hex-digits (the first one
519  *   must be in the range 0..9), this is considered a fingerprint.
520  * - If the username starts with a left angle, we assume it is a complete
521  *   email address and look only at this part.
522  * - If the username starts with a '.', we assume it is the ending
523  *   part of an email address
524  * - If the username starts with an '@', we assume it is a part of an
525  *   email address
526  * - If the userid start with an '=' an exact compare is done.
527  * - If the userid starts with a '*' a case insensitive substring search is
528  *   done (This is the default).
529  * - If the userid starts with a '+' we will compare individual words
530  *   and a match requires that all the words are in the userid.
531  *   Words are delimited by white space or "()<>[]{}.@-+_,;/&!"
532  *   (note that you can't search for these characters). Compare
533  *   is not case sensitive.
534  */
535
536 int
537 classify_user_id( const char *name, u32 *keyid, byte *fprint,
538                   const char **retstr, size_t *retlen )
539 {
540     const char *s;
541     int mode = 0;
542
543     /* check what kind of name it is */
544     for(s = name; *s && isspace(*s); s++ )
545         ;
546     if( isdigit( *s ) ) { /* a keyid or a fingerprint */
547         int i, j;
548         char buf[9];
549
550         if( *s == '0' && s[1] == 'x' && isxdigit(s[2]) )
551             s += 2; /*kludge to allow 0x034343434 */
552         for(i=0; isxdigit(s[i]); i++ )
553             ;
554         if( s[i] && !isspace(s[i]) ) /* not terminated by EOS or blank*/
555             return 0;
556         else if( i == 8 || (i == 9 && *s == '0') ) { /* short keyid */
557             if( i==9 )
558                 s++;
559             if( keyid ) {
560                 keyid[0] = 0;
561                 keyid[1] = strtoul( s, NULL, 16 );
562             }
563             mode = 10;
564         }
565         else if( i == 16 || (i == 17 && *s == '0') ) { /* complete keyid */
566             if( i==17 )
567                 s++;
568             mem2str(buf, s, 9 );
569             keyid[0] = strtoul( buf, NULL, 16 );
570             keyid[1] = strtoul( s+8, NULL, 16 );
571             mode = 11;
572         }
573         else if( i == 32 || ( i == 33 && *s == '0' ) ) { /* md5 fingerprint */
574             if( i==33 )
575                 s++;
576             if( fprint ) {
577                 memset(fprint+16, 4, 0);
578                 for(j=0; j < 16; j++, s+=2 ) {
579                     int c = hextobyte( s );
580                     if( c == -1 )
581                         return 0;
582                     fprint[j] = c;
583                 }
584             }
585             mode = 16;
586         }
587         else if( i == 40 || ( i == 41 && *s == '0' ) ) { /* sha1/rmd160 fprint*/
588             if( i==33 )
589                 s++;
590             if( fprint ) {
591                 for(j=0; j < 20; j++, s+=2 ) {
592                     int c = hextobyte( s );
593                     if( c == -1 )
594                         return 0;
595                     fprint[j] = c;
596                 }
597             }
598             mode = 20;
599         }
600         else
601             return 0;
602     }
603     else if( *s == '=' ) { /* exact search */
604         mode = 1;
605         s++;
606     }
607     else if( *s == '*' ) { /* substring search */
608         mode = 2;
609         s++;
610     }
611     else if( *s == '<' ) { /* an email address */
612         mode = 3;
613     }
614     else if( *s == '@' ) { /* a part of an email address */
615         mode = 4;
616         s++;
617     }
618     else if( *s == '.' ) { /* an email address, compare from end */
619         mode = 5;
620         s++;
621     }
622     else if( *s == '+' ) { /* word match mode */
623         mode = 6;
624         s++;
625     }
626     else if( *s == '#' ) { /* use local id */
627         return 0;
628     }
629     else if( !*s )  /* empty string */
630         return 0;
631     else
632         mode = 2;
633
634     if( retstr )
635         *retstr = s;
636     if( retlen )
637         *retlen = strlen(s);
638
639     return mode;
640 }
641
642
643
644 /****************
645  * Try to get the pubkey by the userid. This function looks for the
646  * first pubkey certificate which has the given name in a user_id.
647  * if pk/sk has the pubkey algo set, the function will only return
648  * a pubkey with that algo.
649  * The caller must provide provide storage for either the pk or the sk.
650  * If ret_kb is not NULL the funtion will return the keyblock there.
651  */
652
653 static int
654 key_byname( GETKEY_CTX *retctx, STRLIST namelist,
655             PKT_public_key *pk, PKT_secret_key *sk, KBNODE *ret_kb )
656 {
657     int rc = 0;
658     int n;
659     STRLIST r;
660     GETKEY_CTX ctx;
661
662     assert( !pk ^ !sk );
663
664     /* build the search context */
665     /* Performance hint: Use a static buffer if there is only one name */
666     /*                   and we don't have mode 6 */
667     for(n=0, r=namelist; r; r = r->next )
668         n++;
669     ctx = m_alloc_clear( sizeof *ctx + (n-1)*sizeof ctx->items );
670     ctx->nitems = n;
671
672     for(n=0, r=namelist; r; r = r->next, n++ ) {
673         ctx->items[n].mode = classify_user_id( r->d,
674                                               ctx->items[n].keyid,
675                                               ctx->items[n].fprint,
676                                               &ctx->items[n].name,
677                                               NULL );
678         if( !ctx->items[n].mode ) {
679             m_free( ctx );
680             return G10ERR_INV_USER_ID;
681         }
682         if( ctx->items[n].mode == 6 ) {
683             ctx->items[n].namebuf = prepare_word_match(ctx->items[n].name);
684             ctx->items[n].name = ctx->items[n].namebuf;
685         }
686     }
687
688     /* and call the lookup function */
689     ctx->primary = 1; /* we want to look for the primary key only */
690     if( sk )
691         rc = lookup_sk( ctx, sk, ret_kb );
692     else
693         rc = lookup_pk( ctx, pk, ret_kb );
694
695     if( retctx ) /* caller wants the context */
696         *retctx = ctx;
697     else {
698         for(n=0; n < ctx->nitems; n++ )
699             m_free( ctx->items[n].namebuf );
700         m_free( ctx );
701     }
702
703     return rc;
704 }
705
706 int
707 get_pubkey_byname( GETKEY_CTX *retctx, PKT_public_key *pk,
708                    const char *name, KBNODE *ret_keyblock )
709 {
710     int rc;
711     STRLIST namelist = NULL;
712
713     add_to_strlist( &namelist, name );
714
715     if( !pk ) {
716         /* Performance Hint: key_byname should not need a pk here */
717         pk = m_alloc_clear( sizeof *pk );
718         rc = key_byname( retctx, namelist, pk, NULL, ret_keyblock );
719         free_public_key( pk );
720     }
721     else
722         rc = key_byname( retctx, namelist, pk, NULL, ret_keyblock );
723
724     free_strlist( namelist );
725     return rc;
726 }
727
728 int
729 get_pubkey_bynames( GETKEY_CTX *retctx, PKT_public_key *pk,
730                     STRLIST names, KBNODE *ret_keyblock )
731 {
732     int rc;
733
734     if( !pk ) {
735         /* Performance Hint: key_byname should not need a pk here */
736         pk = m_alloc_clear( sizeof *pk );
737         rc = key_byname( retctx, names, pk, NULL, ret_keyblock );
738         free_public_key( pk );
739     }
740     else
741         rc = key_byname( retctx, names, pk, NULL, ret_keyblock );
742
743     return rc;
744 }
745
746 int
747 get_pubkey_next( GETKEY_CTX ctx, PKT_public_key *pk, KBNODE *ret_keyblock )
748 {
749     int rc;
750
751     if( !pk ) {
752         /* Performance Hint: lookup_read should not need a pk in this case */
753         pk = m_alloc_clear( sizeof *pk );
754         rc = lookup_pk( ctx, pk, ret_keyblock );
755         free_public_key( pk );
756     }
757     else
758         rc = lookup_pk( ctx, pk, ret_keyblock );
759     return rc;
760 }
761
762 void
763 get_pubkey_end( GETKEY_CTX ctx )
764 {
765     if( ctx ) {
766         int n;
767
768         enum_keyblocks( 2, &ctx->kbpos, NULL ); /* close */
769         for(n=0; n < ctx->nitems; n++ )
770             m_free( ctx->items[n].namebuf );
771         if( !ctx->not_allocated )
772             m_free( ctx );
773     }
774 }
775
776 /****************
777  * Search for a key with the given fingerprint.
778  */
779 int
780 get_pubkey_byfprint( PKT_public_key *pk, const byte *fprint, size_t fprint_len)
781 {
782     int rc;
783
784     if( fprint_len == 20 || fprint_len == 16 ) {
785         struct getkey_ctx_s ctx;
786         memset( &ctx, 0, sizeof ctx );
787         ctx.not_allocated = 1;
788         ctx.nitems = 1;
789         ctx.items[0].mode = fprint_len;
790         memcpy( ctx.items[0].fprint, fprint, fprint_len );
791         rc = lookup_pk( &ctx, pk, NULL );
792         get_pubkey_end( &ctx );
793     }
794     else
795         rc = G10ERR_GENERAL; /* Oops */
796     return rc;
797 }
798
799 /****************
800  * Search for a key with the given fingerprint and return the
801  * complete keyblock which may have more than only this key.
802  */
803 int
804 get_keyblock_byfprint( KBNODE *ret_keyblock, const byte *fprint,
805                                                 size_t fprint_len )
806 {
807     int rc;
808     PKT_public_key *pk = m_alloc_clear( sizeof *pk );
809
810     if( fprint_len == 20 || fprint_len == 16 ) {
811         struct getkey_ctx_s ctx;
812         memset( &ctx, 0, sizeof ctx );
813         ctx.not_allocated = 1;
814         ctx.nitems = 1;
815         ctx.items[0].mode = fprint_len;
816         memcpy( ctx.items[0].fprint, fprint, fprint_len );
817         rc = lookup_pk( &ctx, pk, ret_keyblock );
818         get_pubkey_end( &ctx );
819     }
820     else
821         rc = G10ERR_GENERAL; /* Oops */
822
823     free_public_key( pk );
824     return rc;
825 }
826
827
828
829
830
831 /****************
832  * Get a secret key by name and store it into sk
833  * If NAME is NULL use the default key
834  */
835 int
836 get_seckey_byname( PKT_secret_key *sk, const char *name, int unprotect )
837 {
838     STRLIST namelist = NULL;
839     int rc;
840
841     if( !name && opt.def_secret_key && *opt.def_secret_key ) {
842         add_to_strlist( &namelist, opt.def_secret_key );
843         rc = key_byname( NULL, namelist, NULL, sk, NULL );
844     }
845     else if( !name ) { /* use the first one as default key */
846         struct getkey_ctx_s ctx;
847
848         memset( &ctx, 0, sizeof ctx );
849         ctx.not_allocated = 1;
850         ctx.primary = 1;
851         ctx.nitems = 1;
852         ctx.items[0].mode = 15;
853         rc = lookup_sk( &ctx, sk, NULL );
854         get_seckey_end( &ctx );
855     }
856     else {
857         add_to_strlist( &namelist, name );
858         rc = key_byname( NULL, namelist, NULL, sk, NULL );
859     }
860
861     free_strlist( namelist );
862
863     if( !rc && unprotect )
864         rc = check_secret_key( sk, 0 );
865
866     return rc;
867 }
868
869 int
870 get_seckey_bynames( GETKEY_CTX *retctx, PKT_secret_key *sk,
871                     STRLIST names, KBNODE *ret_keyblock )
872 {
873     int rc;
874
875     if( !sk ) {
876         /* Performance Hint: key_byname should not need a sk here */
877         sk = m_alloc_secure_clear( sizeof *sk );
878         rc = key_byname( retctx, names, NULL, sk, ret_keyblock );
879         free_secret_key( sk );
880     }
881     else
882         rc = key_byname( retctx, names, NULL, sk, ret_keyblock );
883
884     return rc;
885 }
886
887
888 int
889 get_seckey_next( GETKEY_CTX ctx, PKT_secret_key *sk, KBNODE *ret_keyblock )
890 {
891     int rc;
892
893     if( !sk ) {
894         /* Performance Hint: lookup_read should not need a pk in this case */
895         sk = m_alloc_secure_clear( sizeof *sk );
896         rc = lookup_sk( ctx, sk, ret_keyblock );
897         free_secret_key( sk );
898     }
899     else
900         rc = lookup_sk( ctx, sk, ret_keyblock );
901     return rc;
902 }
903
904 void
905 get_seckey_end( GETKEY_CTX ctx )
906 {
907     if( ctx ) {
908         int n;
909
910         enum_keyblocks( 2, &ctx->kbpos, NULL ); /* close */
911         for(n=0; n < ctx->nitems; n++ )
912             m_free( ctx->items[n].namebuf );
913         if( !ctx->not_allocated )
914             m_free( ctx );
915     }
916 }
917
918
919
920 /****************
921  * Do a word match (original user id starts with a '+').
922  * The pattern is already tokenized to a more suitable format:
923  * There are only the real words in it delimited by one space
924  * and all converted to uppercase.
925  *
926  * Returns: 0 if all words match.
927  *
928  * Note: This algorithm is a straightforward one and not very
929  *       fast.  It works for UTF-8 strings.  The uidlen should
930  *       be removed but due to the fact that old versions of
931  *       pgp don't use UTF-8 we still use the length; this should
932  *       be fixed in parse-packet (and replace \0 by some special
933  *       UTF-8 encoding)
934  */
935 static int
936 word_match( const byte *uid, size_t uidlen, const byte *pattern )
937 {
938     size_t wlen, n;
939     const byte *p;
940     const byte *s;
941
942     for( s=pattern; *s; ) {
943         do {
944             /* skip leading delimiters */
945             while( uidlen && !word_match_chars[*uid] )
946                 uid++, uidlen--;
947             /* get length of the word */
948             n = uidlen; p = uid;
949             while( n && word_match_chars[*p] )
950                 p++, n--;
951             wlen = p - uid;
952             /* and compare against the current word from pattern */
953             for(n=0, p=uid; n < wlen && s[n] != ' ' && s[n] ; n++, p++ ) {
954                 if( word_match_chars[*p] != s[n] )
955                     break;
956             }
957             if( n == wlen && (s[n] == ' ' || !s[n]) )
958                 break; /* found */
959             uid += wlen;
960             uidlen -= wlen;
961         } while( uidlen );
962         if( !uidlen )
963             return -1; /* not found */
964
965         /* advance to next word in pattern */
966         for(; *s != ' ' && *s ; s++ )
967             ;
968         if( *s )
969             s++ ;
970     }
971     return 0; /* found */
972 }
973
974 /****************
975  * prepare word word_match; that is parse the name and
976  * build the pattern.
977  * caller has to free the returned pattern
978  */
979 static char*
980 prepare_word_match( const byte *name )
981 {
982     byte *pattern, *p;
983     int c;
984
985     /* the original length is always enough for the pattern */
986     p = pattern = m_alloc(strlen(name)+1);
987     do {
988         /* skip leading delimiters */
989         while( *name && !word_match_chars[*name] )
990             name++;
991         /* copy as long as we don't have a delimiter and convert
992          * to uppercase.
993          * fixme: how can we handle utf8 uppercasing */
994         for( ; *name &&  (c=word_match_chars[*name]); name++ )
995             *p++ = c;
996         *p++ = ' '; /* append pattern delimiter */
997     } while( *name );
998     p[-1] = 0; /* replace last pattern delimiter by EOS */
999
1000     return pattern;
1001 }
1002
1003
1004
1005
1006
1007 static int
1008 compare_name( const char *uid, size_t uidlen, const char *name, int mode )
1009 {
1010     int i;
1011     const char *s, *se;
1012
1013     if( mode == 1 ) {  /* exact match */
1014         for(i=0; name[i] && uidlen; i++, uidlen-- )
1015             if( uid[i] != name[i] )
1016                 break;
1017         if( !uidlen && !name[i] )
1018             return 0; /* found */
1019     }
1020     else if( mode == 2 ) { /* case insensitive substring */
1021         if( memistr( uid, uidlen, name ) )
1022             return 0;
1023     }
1024     else if( mode >= 3 && mode <= 5 ) { /* look at the email address */
1025         for( i=0, s= uid; i < uidlen && *s != '<'; s++, i++ )
1026             ;
1027         if( i < uidlen )  {
1028             /* skip opening delim and one char and look for the closing one*/
1029             s++; i++;
1030             for( se=s+1, i++; i < uidlen && *se != '>'; se++, i++ )
1031                 ;
1032             if( i < uidlen ) {
1033                 i = se - s;
1034                 if( mode == 3 ) { /* exact email address */
1035                     if( strlen(name)-2 == i && !memicmp( s, name+1, i) )
1036                         return 0;
1037                 }
1038                 else if( mode == 4 ) {  /* email substring */
1039                     if( memistr( s, i, name ) )
1040                         return 0;
1041                 }
1042                 else { /* email from end */
1043                     /* nyi */
1044                 }
1045             }
1046         }
1047     }
1048     else if( mode == 6 )
1049         return word_match( uid, uidlen, name );
1050     else
1051         BUG();
1052
1053     return -1; /* not found */
1054 }
1055
1056
1057
1058 /****************
1059  * Assume that knode points to a public key packet  and keyblock is
1060  * the entire keyblock.  This function adds all relevant information from
1061  * a selfsignature to the public key.
1062  */
1063
1064 static void
1065 merge_one_pk_and_selfsig( KBNODE keyblock, KBNODE knode,
1066                           PKT_public_key *orig_pk )
1067 {
1068     PKT_public_key *pk = knode->pkt->pkt.public_key;
1069     PKT_signature *sig;
1070     KBNODE k;
1071     u32 kid[2];
1072     u32 sigdate = 0;
1073
1074     assert(    knode->pkt->pkttype == PKT_PUBLIC_KEY
1075             || knode->pkt->pkttype == PKT_PUBLIC_SUBKEY );
1076
1077     if( pk->version < 4 )
1078         return; /* this is only needed for version >=4 packets */
1079
1080
1081     /* find the selfsignature */
1082     if( knode->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
1083         k = find_kbnode( keyblock, PKT_PUBLIC_KEY );
1084         if( !k )
1085            BUG(); /* keyblock without primary key!!! */
1086         keyid_from_pk( knode->pkt->pkt.public_key, kid );
1087     }
1088     else
1089         keyid_from_pk( pk, kid );
1090
1091     for(k=knode->next; k; k = k->next ) {
1092         if( k->pkt->pkttype == PKT_SIGNATURE
1093             && (sig=k->pkt->pkt.signature)->sig_class >= 0x10
1094             && sig->sig_class <= 0x30
1095             && sig->keyid[0] == kid[0]
1096             && sig->keyid[1] == kid[1]
1097             && sig->version > 3 ) {
1098             /* okay this is a self-signature which can be used.
1099              * We use the latest self-signature.
1100              * FIXME: We should only use this if the signature is valid
1101              *        but this is time consuming - we must provide another
1102              *        way to handle this
1103              */
1104             const byte *p;
1105             u32 ed;
1106
1107             p = parse_sig_subpkt( sig->hashed_data, SIGSUBPKT_KEY_EXPIRE, NULL );
1108             ed = p? pk->timestamp + buffer_to_u32(p):0;
1109             /* use the latest self signature */
1110             if( sig->timestamp > sigdate ) {
1111                 pk->expiredate = ed;
1112                 orig_pk->expiredate = ed;
1113                 sigdate = sig->timestamp;
1114             }
1115             /* fixme: add usage etc. to pk */
1116         }
1117         else if( k->pkt->pkttype == PKT_PUBLIC_SUBKEY )
1118             break; /* stop here */
1119     }
1120 }
1121
1122
1123 /****************
1124  * merge all selfsignatures with the keys.
1125  */
1126 void
1127 merge_keys_and_selfsig( KBNODE keyblock )
1128 {
1129     PKT_public_key *pk = NULL;
1130     PKT_secret_key *sk = NULL;
1131     PKT_signature *sig;
1132     KBNODE k;
1133     u32 kid[2] = { 0, 0 };
1134     u32 sigdate = 0;
1135
1136     for(k=keyblock; k; k = k->next ) {
1137         if( k->pkt->pkttype == PKT_PUBLIC_KEY
1138             || k->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
1139             pk = k->pkt->pkt.public_key; sk = NULL;
1140             if( pk->version < 4 )
1141                 pk = NULL; /* not needed for old keys */
1142             else if( k->pkt->pkttype == PKT_PUBLIC_KEY )
1143                 keyid_from_pk( pk, kid );
1144             sigdate = 0;
1145         }
1146         else if( k->pkt->pkttype == PKT_SECRET_KEY
1147             || k->pkt->pkttype == PKT_SECRET_SUBKEY ) {
1148             pk = NULL; sk = k->pkt->pkt.secret_key;
1149             if( sk->version < 4 )
1150                 sk = NULL;
1151             else if( k->pkt->pkttype == PKT_SECRET_KEY )
1152                 keyid_from_sk( sk, kid );
1153             sigdate = 0;
1154         }
1155         else if( (pk || sk ) && k->pkt->pkttype == PKT_SIGNATURE
1156                  && (sig=k->pkt->pkt.signature)->sig_class >= 0x10
1157                  && sig->sig_class <= 0x30 && sig->version > 3
1158                  && sig->keyid[0] == kid[0] && sig->keyid[1] == kid[1] ) {
1159             /* okay this is a self-signature which can be used.
1160              * FIXME: We should only use this if the signature is valid
1161              *        but this is time consuming - we must provide another
1162              *        way to handle this
1163              */
1164             const byte *p;
1165             u32 ed;
1166
1167             p = parse_sig_subpkt( sig->hashed_data, SIGSUBPKT_KEY_EXPIRE, NULL );
1168             if( pk ) {
1169                 ed = p? pk->timestamp + buffer_to_u32(p):0;
1170                 if( sig->timestamp > sigdate ) {
1171                     pk->expiredate = ed;
1172                     sigdate = sig->timestamp;
1173                 }
1174             }
1175             else {
1176                 ed = p? sk->timestamp + buffer_to_u32(p):0;
1177                 if( sig->timestamp > sigdate ) {
1178                     sk->expiredate = ed;
1179                     sigdate = sig->timestamp;
1180                 }
1181             }
1182         }
1183     }
1184 }
1185
1186
1187 static KBNODE
1188 find_by_name( KBNODE keyblock, PKT_public_key *pk, const char *name,
1189               int mode, byte *namehash, int *use_namehash )
1190 {
1191     KBNODE k, kk;
1192
1193     for(k=keyblock; k; k = k->next ) {
1194         if( k->pkt->pkttype == PKT_USER_ID
1195             && !compare_name( k->pkt->pkt.user_id->name,
1196                               k->pkt->pkt.user_id->len, name, mode)) {
1197             /* we found a matching name, look for the key */
1198             for(kk=keyblock; kk; kk = kk->next ) {
1199                 if( (    kk->pkt->pkttype == PKT_PUBLIC_KEY
1200                       || kk->pkt->pkttype == PKT_PUBLIC_SUBKEY )
1201                     && ( !pk->pubkey_algo
1202                          || pk->pubkey_algo
1203                             == kk->pkt->pkt.public_key->pubkey_algo)
1204                     && ( !pk->pubkey_usage
1205                          || !check_pubkey_algo2(
1206                                kk->pkt->pkt.public_key->pubkey_algo,
1207                                                    pk->pubkey_usage ))
1208                   )
1209                     break;
1210             }
1211             if( kk ) {
1212                 u32 aki[2];
1213                 keyid_from_pk( kk->pkt->pkt.public_key, aki );
1214                 cache_user_id( k->pkt->pkt.user_id, aki );
1215                 rmd160_hash_buffer( namehash,
1216                                     k->pkt->pkt.user_id->name,
1217                                     k->pkt->pkt.user_id->len );
1218                 *use_namehash = 1;
1219                 return kk;
1220             }
1221             else if( is_RSA(pk->pubkey_algo) )
1222                 log_error("RSA key cannot be used in this version\n");
1223             else
1224                 log_error("No key for userid\n");
1225         }
1226     }
1227     return NULL;
1228 }
1229
1230 static KBNODE
1231 find_by_name_sk( KBNODE keyblock, PKT_secret_key *sk, const char *name,
1232                  int mode )
1233 {
1234     KBNODE k, kk;
1235
1236     for(k=keyblock; k; k = k->next ) {
1237         if( k->pkt->pkttype == PKT_USER_ID
1238             && !compare_name( k->pkt->pkt.user_id->name,
1239                               k->pkt->pkt.user_id->len, name, mode)) {
1240             /* we found a matching name, look for the key */
1241             for(kk=keyblock; kk; kk = kk->next ) {
1242                 if( (    kk->pkt->pkttype == PKT_SECRET_KEY
1243                       || kk->pkt->pkttype == PKT_SECRET_SUBKEY )
1244                     && ( !sk->pubkey_algo
1245                          || sk->pubkey_algo
1246                             == kk->pkt->pkt.secret_key->pubkey_algo)
1247                     && ( !sk->pubkey_usage
1248                          || !check_pubkey_algo2(
1249                                kk->pkt->pkt.secret_key->pubkey_algo,
1250                                                    sk->pubkey_usage ))
1251                   )
1252                     break;
1253             }
1254             if( kk ) {
1255                 u32 aki[2];
1256                 keyid_from_sk( kk->pkt->pkt.secret_key, aki );
1257                 cache_user_id( k->pkt->pkt.user_id, aki );
1258                 return kk;
1259             }
1260             else if( is_RSA(sk->pubkey_algo) )
1261                 log_error("RSA key cannot be used in this version\n");
1262             else
1263                 log_error("No key for userid\n");
1264         }
1265     }
1266     return NULL;
1267 }
1268
1269
1270 static KBNODE
1271 find_by_keyid( KBNODE keyblock, PKT_public_key *pk, u32 *keyid, int mode )
1272 {
1273     KBNODE k;
1274
1275     if( DBG_CACHE )
1276         log_debug("lookup keyid=%08lx%08lx req_algo=%d mode=%d\n",
1277                    (ulong)keyid[0], (ulong)keyid[1], pk->pubkey_algo, mode );
1278
1279     for(k=keyblock; k; k = k->next ) {
1280         if(    k->pkt->pkttype == PKT_PUBLIC_KEY
1281             || k->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
1282             u32 aki[2];
1283             keyid_from_pk( k->pkt->pkt.public_key, aki );
1284             if( DBG_CACHE )
1285                 log_debug("         aki=%08lx%08lx algo=%d\n",
1286                                 (ulong)aki[0], (ulong)aki[1],
1287                                  k->pkt->pkt.public_key->pubkey_algo    );
1288
1289             if( aki[1] == keyid[1]
1290                 && ( mode == 10 || aki[0] == keyid[0] )
1291                 && ( !pk->pubkey_algo
1292                      || pk->pubkey_algo
1293                         == k->pkt->pkt.public_key->pubkey_algo) ){
1294                 KBNODE kk;
1295                 /* cache the userid */
1296                 for(kk=keyblock; kk; kk = kk->next )
1297                     if( kk->pkt->pkttype == PKT_USER_ID )
1298                         break;
1299                 if( kk )
1300                     cache_user_id( kk->pkt->pkt.user_id, aki );
1301                 else
1302                     log_error("No userid for key\n");
1303                 return k; /* found */
1304             }
1305         }
1306     }
1307     return NULL;
1308 }
1309
1310 static KBNODE
1311 find_by_keyid_sk( KBNODE keyblock, PKT_secret_key *sk, u32 *keyid, int mode )
1312 {
1313     KBNODE k;
1314
1315     if( DBG_CACHE )
1316         log_debug("lookup_sk keyid=%08lx%08lx req_algo=%d mode=%d\n",
1317                    (ulong)keyid[0], (ulong)keyid[1], sk->pubkey_algo, mode );
1318
1319     for(k=keyblock; k; k = k->next ) {
1320         if(    k->pkt->pkttype == PKT_SECRET_KEY
1321             || k->pkt->pkttype == PKT_SECRET_SUBKEY ) {
1322             u32 aki[2];
1323             keyid_from_sk( k->pkt->pkt.secret_key, aki );
1324             if( DBG_CACHE )
1325                 log_debug("         aki=%08lx%08lx algo=%d\n",
1326                                 (ulong)aki[0], (ulong)aki[1],
1327                                  k->pkt->pkt.secret_key->pubkey_algo    );
1328
1329             if( aki[1] == keyid[1]
1330                 && ( mode == 10 || aki[0] == keyid[0] )
1331                 && ( !sk->pubkey_algo
1332                      || sk->pubkey_algo
1333                         == k->pkt->pkt.secret_key->pubkey_algo) ){
1334                 KBNODE kk;
1335                 /* cache the userid */
1336                 for(kk=keyblock; kk; kk = kk->next )
1337                     if( kk->pkt->pkttype == PKT_USER_ID )
1338                         break;
1339                 if( kk )
1340                     cache_user_id( kk->pkt->pkt.user_id, aki );
1341                 else
1342                     log_error("No userid for key\n");
1343                 return k; /* found */
1344             }
1345         }
1346     }
1347     return NULL;
1348 }
1349
1350
1351 static KBNODE
1352 find_first( KBNODE keyblock, PKT_public_key *pk )
1353 {
1354     KBNODE k;
1355
1356     for(k=keyblock; k; k = k->next ) {
1357         if(    k->pkt->pkttype == PKT_PUBLIC_KEY
1358             || k->pkt->pkttype == PKT_PUBLIC_SUBKEY )
1359         {
1360             if( !pk->pubkey_algo
1361                 || pk->pubkey_algo == k->pkt->pkt.public_key->pubkey_algo )
1362                 return k;
1363         }
1364     }
1365     return NULL;
1366 }
1367
1368 static KBNODE
1369 find_first_sk( KBNODE keyblock, PKT_secret_key *sk )
1370 {
1371     KBNODE k;
1372
1373     for(k=keyblock; k; k = k->next ) {
1374         if(    k->pkt->pkttype == PKT_SECRET_KEY
1375             || k->pkt->pkttype == PKT_SECRET_SUBKEY )
1376         {
1377             if( !sk->pubkey_algo
1378                 || sk->pubkey_algo == k->pkt->pkt.secret_key->pubkey_algo )
1379                 return k;
1380         }
1381     }
1382     return NULL;
1383 }
1384
1385
1386 static KBNODE
1387 find_by_fpr( KBNODE keyblock, PKT_public_key *pk, const char *name, int mode )
1388 {
1389     KBNODE k;
1390
1391     for(k=keyblock; k; k = k->next ) {
1392         if(    k->pkt->pkttype == PKT_PUBLIC_KEY
1393             || k->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
1394             byte afp[MAX_FINGERPRINT_LEN];
1395             size_t an;
1396
1397             fingerprint_from_pk(k->pkt->pkt.public_key, afp, &an );
1398
1399             if( DBG_CACHE ) {
1400                 u32 aki[2];
1401                 keyid_from_pk( k->pkt->pkt.public_key, aki );
1402                 log_debug("         aki=%08lx%08lx algo=%d mode=%d an=%u\n",
1403                                 (ulong)aki[0], (ulong)aki[1],
1404                         k->pkt->pkt.public_key->pubkey_algo, mode, an );
1405             }
1406
1407             if( an == mode
1408                 && !memcmp( afp, name, an)
1409                 && ( !pk->pubkey_algo
1410                      || pk->pubkey_algo == k->pkt->pkt.public_key->pubkey_algo) )
1411                 return k;
1412         }
1413     }
1414     return NULL;
1415 }
1416
1417 static KBNODE
1418 find_by_fpr_sk( KBNODE keyblock, PKT_secret_key *sk,
1419                                  const char *name, int mode )
1420 {
1421     KBNODE k;
1422
1423     for(k=keyblock; k; k = k->next ) {
1424         if(    k->pkt->pkttype == PKT_SECRET_KEY
1425             || k->pkt->pkttype == PKT_SECRET_SUBKEY ) {
1426             byte afp[MAX_FINGERPRINT_LEN];
1427             size_t an;
1428
1429             fingerprint_from_sk(k->pkt->pkt.secret_key, afp, &an );
1430
1431             if( DBG_CACHE ) {
1432                 u32 aki[2];
1433                 keyid_from_sk( k->pkt->pkt.secret_key, aki );
1434                 log_debug("         aki=%08lx%08lx algo=%d mode=%d an=%u\n",
1435                                 (ulong)aki[0], (ulong)aki[1],
1436                         k->pkt->pkt.secret_key->pubkey_algo, mode, an );
1437             }
1438
1439             if( an == mode
1440                 && !memcmp( afp, name, an)
1441                 && ( !sk->pubkey_algo
1442                      || sk->pubkey_algo == k->pkt->pkt.secret_key->pubkey_algo) )
1443                 return k;
1444         }
1445     }
1446     return NULL;
1447 }
1448
1449
1450 static void
1451 finish_lookup( KBNODE keyblock, PKT_public_key *pk, KBNODE k, byte *namehash,
1452                                                int use_namehash, int primary )
1453 {
1454     assert(    k->pkt->pkttype == PKT_PUBLIC_KEY
1455             || k->pkt->pkttype == PKT_PUBLIC_SUBKEY );
1456     assert( keyblock->pkt->pkttype == PKT_PUBLIC_KEY );
1457     if( primary && !pk->pubkey_usage ) {
1458         copy_public_key_new_namehash( pk, keyblock->pkt->pkt.public_key,
1459                                       use_namehash? namehash:NULL);
1460         merge_one_pk_and_selfsig( keyblock, keyblock, pk );
1461     }
1462     else {
1463         if( primary && pk->pubkey_usage
1464             && check_pubkey_algo2( k->pkt->pkt.public_key->pubkey_algo,
1465                        pk->pubkey_usage ) == G10ERR_WR_PUBKEY_ALGO ) {
1466             /* if the usage is not correct, try to use a subkey */
1467             KBNODE save_k = k;
1468
1469             k = NULL;
1470             /* kludge for pgp 5: which doesn't accept type 20:
1471              * try to use a type 16 subkey instead */
1472             if( pk->pubkey_usage == PUBKEY_USAGE_ENC ) {
1473                 for( k = save_k; k; k = k->next ) {
1474                     if( k->pkt->pkttype == PKT_PUBLIC_SUBKEY
1475                         && k->pkt->pkt.public_key->pubkey_algo
1476                             == PUBKEY_ALGO_ELGAMAL_E
1477                         && !check_pubkey_algo2(
1478                                 k->pkt->pkt.public_key->pubkey_algo,
1479                                                  pk->pubkey_usage ) )
1480                         break;
1481                 }
1482             }
1483
1484             if( !k ) {
1485                 for(k = save_k ; k; k = k->next ) {
1486                     if( k->pkt->pkttype == PKT_PUBLIC_SUBKEY
1487                         && !check_pubkey_algo2(
1488                                 k->pkt->pkt.public_key->pubkey_algo,
1489                                                  pk->pubkey_usage ) )
1490                         break;
1491                 }
1492             }
1493             if( !k )
1494                 k = save_k;
1495             else
1496                 log_info(_("using secondary key %08lX "
1497                            "instead of primary key %08lX\n"),
1498                       (ulong)keyid_from_pk( k->pkt->pkt.public_key, NULL),
1499                       (ulong)keyid_from_pk( save_k->pkt->pkt.public_key, NULL)
1500                         );
1501         }
1502
1503         copy_public_key_new_namehash( pk, k->pkt->pkt.public_key,
1504                                       use_namehash? namehash:NULL);
1505         merge_one_pk_and_selfsig( keyblock, k, pk );
1506     }
1507 }
1508
1509 static void
1510 finish_lookup_sk( KBNODE keyblock, PKT_secret_key *sk, KBNODE k, int primary )
1511 {
1512     assert(    k->pkt->pkttype == PKT_SECRET_KEY
1513             || k->pkt->pkttype == PKT_SECRET_SUBKEY );
1514     assert( keyblock->pkt->pkttype == PKT_SECRET_KEY );
1515     if( primary && !sk->pubkey_usage ) {
1516         copy_secret_key( sk, keyblock->pkt->pkt.secret_key );
1517     }
1518     else {
1519         if( primary && sk->pubkey_usage
1520             && check_pubkey_algo2( k->pkt->pkt.secret_key->pubkey_algo,
1521                        sk->pubkey_usage ) == G10ERR_WR_PUBKEY_ALGO ) {
1522             /* if the usage is not correct, try to use a subkey */
1523             KBNODE save_k = k;
1524
1525             k = NULL;
1526             /* kludge for pgp 5: which doesn't accept type 20:
1527              * try to use a type 16 subkey instead */
1528             if( sk->pubkey_usage == PUBKEY_USAGE_ENC ) {
1529                 for( k = save_k; k; k = k->next ) {
1530                     if( k->pkt->pkttype == PKT_SECRET_SUBKEY
1531                         && k->pkt->pkt.secret_key->pubkey_algo
1532                             == PUBKEY_ALGO_ELGAMAL_E
1533                         && !check_pubkey_algo2(
1534                                 k->pkt->pkt.secret_key->pubkey_algo,
1535                                                  sk->pubkey_usage ) )
1536                         break;
1537                 }
1538             }
1539
1540             if( !k ) {
1541                 for(k = save_k ; k; k = k->next ) {
1542                     if( k->pkt->pkttype == PKT_SECRET_SUBKEY
1543                         && !check_pubkey_algo2(
1544                                 k->pkt->pkt.secret_key->pubkey_algo,
1545                                                  sk->pubkey_usage ) )
1546                         break;
1547                 }
1548             }
1549             if( !k )
1550                 k = save_k;
1551             else
1552                 log_info(_("using secondary key %08lX "
1553                            "instead of primary key %08lX\n"),
1554                       (ulong)keyid_from_sk( k->pkt->pkt.secret_key, NULL),
1555                       (ulong)keyid_from_sk( save_k->pkt->pkt.secret_key, NULL)
1556                         );
1557         }
1558
1559         copy_secret_key( sk, k->pkt->pkt.secret_key );
1560     }
1561 }
1562
1563
1564 /****** old code from lookup_read ******/
1565 #if 0 /* can't use it anymore - invent a more general approach */
1566     /* try the quick functions */
1567     if( !ctx->count ) {
1568         k = NULL;
1569         switch( ctx->mode ) {
1570           case 10:
1571           case 11:
1572             rc = locate_keyblock_by_keyid( &ctx->kbpos, ctx->keyid,
1573                                                         ctx->mode==10, 0 );
1574             if( !rc )
1575                 rc = read_keyblock( &ctx->kbpos, &ctx->keyblock );
1576             if( !rc )
1577                 k = find_by_keyid( ctx->keyblock, pk, ctx->keyid, ctx->mode );
1578             break;
1579
1580           case 16:
1581           case 20:
1582             rc = locate_keyblock_by_fpr( &ctx->kbpos, ctx->name, ctx->mode, 0 );
1583             if( !rc )
1584                 rc = read_keyblock( &ctx->kbpos, &ctx->keyblock );
1585             if( !rc )
1586                 k = find_by_fpr( ctx->keyblock, pk, ctx->name, ctx->mode );
1587             break;
1588
1589           default: rc = G10ERR_UNSUPPORTED;
1590         }
1591         if( !rc ) {
1592             if( !k ) {
1593                 log_error("lookup: key has been located but was not found\n");
1594                 rc = G10ERR_INV_KEYRING;
1595             }
1596             else
1597                 finish_lookup( ctx->keyblock, pk, k, namehash, 0, ctx->primary );
1598         }
1599     }
1600     else
1601         rc = G10ERR_UNSUPPORTED;
1602
1603     /* if this was not possible, loop over all keyblocks
1604      * fixme: If one of the resources in the quick functions above
1605      *        works, but the key was not found, we will not find it
1606      *        in the other resources */
1607     if( rc == G10ERR_UNSUPPORTED ) {
1608     }
1609 #endif
1610
1611
1612 static int
1613 lookup_pk( GETKEY_CTX ctx, PKT_public_key *pk, KBNODE *ret_keyblock )
1614 {
1615     int rc;
1616     KBNODE k;
1617     int oldmode = set_packet_list_mode(0);
1618     byte namehash[20];
1619     int use_namehash=0;
1620
1621     if( !ctx->count ) /* first time */
1622         rc = enum_keyblocks( 0, &ctx->kbpos, &ctx->keyblock );
1623     else
1624         rc = 0;
1625     if( !rc ) {
1626         while( !(rc = enum_keyblocks( 1, &ctx->kbpos, &ctx->keyblock )) ) {
1627             int n;
1628             getkey_item_t *item;
1629             /* fixme: we don't enum the complete keyblock, but
1630              * use the first match and then continue with the next keyblock
1631              */
1632             /* loop over all the user ids we want to look for */
1633             item = ctx->items;
1634             for(n=0; n < ctx->nitems; n++, item++ ) {
1635                 if( item->mode < 10 )
1636                     k = find_by_name( ctx->keyblock, pk,
1637                                       item->name, item->mode,
1638                                       namehash, &use_namehash );
1639                 else if( item->mode == 10 || item->mode == 11 )
1640                     k = find_by_keyid( ctx->keyblock, pk,
1641                                        item->keyid, item->mode );
1642                 else if( item->mode == 15 )
1643                     k = find_first( ctx->keyblock, pk );
1644                 else if( item->mode == 16 || item->mode == 20 )
1645                     k = find_by_fpr( ctx->keyblock, pk,
1646                                      item->fprint, item->mode );
1647                 else
1648                     BUG();
1649                 if( k ) {
1650                     finish_lookup( ctx->keyblock, pk, k, namehash,
1651                                                  use_namehash, ctx->primary );
1652                     goto found;
1653                 }
1654             }
1655             release_kbnode( ctx->keyblock );
1656             ctx->keyblock = NULL;
1657         }
1658       found: ;
1659     }
1660     if( rc && rc != -1 )
1661         log_error("enum_keyblocks failed: %s\n", g10_errstr(rc));
1662
1663     if( !rc ) {
1664         if( ret_keyblock ) {
1665             *ret_keyblock = ctx->keyblock;
1666             ctx->keyblock = NULL;
1667         }
1668     }
1669     else if( rc == -1 )
1670         rc = G10ERR_NO_PUBKEY;
1671
1672     release_kbnode( ctx->keyblock );
1673     ctx->keyblock = NULL;
1674     set_packet_list_mode(oldmode);
1675   #if 0
1676     if( opt.debug & DBG_MEMSTAT_VALUE ) {
1677         static int initialized;
1678
1679         if( !initialized ) {
1680             initialized = 1;
1681             atexit( print_stats );
1682         }
1683
1684         assert( ctx->mode < DIM(lkup_stats) );
1685         lkup_stats[ctx->mode].any = 1;
1686         if( !rc )
1687             lkup_stats[ctx->mode].okay_count++;
1688         else if ( rc == G10ERR_NO_PUBKEY )
1689             lkup_stats[ctx->mode].nokey_count++;
1690         else
1691             lkup_stats[ctx->mode].error_count++;
1692     }
1693    #endif
1694
1695     ctx->last_rc = rc;
1696     ctx->count++;
1697     return rc;
1698 }
1699
1700
1701
1702 static int
1703 lookup_sk( GETKEY_CTX ctx, PKT_secret_key *sk, KBNODE *ret_keyblock )
1704 {
1705     int rc;
1706     KBNODE k;
1707     int oldmode = set_packet_list_mode(0);
1708
1709     if( !ctx->count ) /* first time */
1710         rc = enum_keyblocks( 5, &ctx->kbpos, &ctx->keyblock );
1711     else
1712         rc = 0;
1713     if( !rc ) {
1714         while( !(rc = enum_keyblocks( 1, &ctx->kbpos, &ctx->keyblock )) ) {
1715             int n;
1716             getkey_item_t *item;
1717             /* fixme: we don't enum the complete keyblock, but
1718              * use the first match and then continue with the next keyblock
1719              */
1720             /* loop over all the user ids we want to look for */
1721             item = ctx->items;
1722             for(n=0; n < ctx->nitems; n++, item++ ) {
1723                 if( item->mode < 10 )
1724                     k = find_by_name_sk( ctx->keyblock, sk,
1725                                          item->name, item->mode );
1726                 else if( item->mode == 10 || item->mode == 11 )
1727                     k = find_by_keyid_sk( ctx->keyblock, sk,
1728                                           item->keyid, item->mode );
1729                 else if( item->mode == 15 )
1730                     k = find_first_sk( ctx->keyblock, sk );
1731                 else if( item->mode == 16 || item->mode == 20 )
1732                     k = find_by_fpr_sk( ctx->keyblock, sk,
1733                                         item->fprint, item->mode );
1734                 else
1735                     BUG();
1736                 if( k ) {
1737                     finish_lookup_sk( ctx->keyblock, sk, k, ctx->primary );
1738                     goto found;
1739                 }
1740             }
1741             release_kbnode( ctx->keyblock );
1742             ctx->keyblock = NULL;
1743         }
1744       found: ;
1745     }
1746     if( rc && rc != -1 )
1747         log_error("enum_keyblocks failed: %s\n", g10_errstr(rc));
1748
1749     if( !rc ) {
1750         if( ret_keyblock ) {
1751             *ret_keyblock = ctx->keyblock;
1752             ctx->keyblock = NULL;
1753         }
1754     }
1755     else if( rc == -1 )
1756         rc = G10ERR_NO_PUBKEY;
1757
1758     release_kbnode( ctx->keyblock );
1759     ctx->keyblock = NULL;
1760     set_packet_list_mode(oldmode);
1761
1762     ctx->last_rc = rc;
1763     ctx->count++;
1764     return rc;
1765 }
1766
1767
1768 #if 0
1769 OLD/************
1770 OLD * Ditto for secret keys WORK!!!!!!
1771 OLD */
1772 OLDstatic int
1773 OLDlookup_sk( PKT_secret_key *sk, int mode,  u32 *keyid, const char *name,
1774 OLD           int primary )
1775 OLD{
1776 OLD    int rc;
1777 OLD    KBNODE keyblock = NULL;
1778 OLD    KBPOS kbpos;
1779 OLD    int oldmode = set_packet_list_mode(0);
1780 OLD
1781 OLD    rc = enum_keyblocks( 5 /* open secret */, &kbpos, &keyblock );
1782 OLD    if( rc ) {
1783 OLD        if( rc == -1 )
1784 OLD            rc = G10ERR_NO_SECKEY;
1785 OLD        else if( rc )
1786 OLD            log_error("enum_keyblocks(open secret) failed: %s\n", g10_errstr(rc) );
1787 OLD        goto leave;
1788 OLD    }
1789 OLD
1790 OLD    while( !(rc = enum_keyblocks( 1, &kbpos, &keyblock )) ) {
1791 OLD        KBNODE k, kk;
1792 OLD        if( mode < 10 ) { /* name lookup */
1793 OLD            for(k=keyblock; k; k = k->next ) {
1794 OLD                if( k->pkt->pkttype == PKT_USER_ID
1795 OLD                    && !compare_name( k->pkt->pkt.user_id->name,
1796 OLD                                      k->pkt->pkt.user_id->len, name, mode)) {
1797 OLD                    /* we found a matching name, look for the key */
1798 OLD                    for(kk=keyblock; kk; kk = kk->next ) {
1799 OLD                        if( (    kk->pkt->pkttype == PKT_SECRET_KEY
1800 OLD                              || kk->pkt->pkttype == PKT_SECRET_SUBKEY )
1801 OLD                            && ( !sk->pubkey_algo
1802 OLD                                 || sk->pubkey_algo
1803 OLD                                    == kk->pkt->pkt.secret_key->pubkey_algo)
1804 OLD                            && ( !sk->pubkey_usage
1805 OLD                                 || !check_pubkey_algo2(
1806 OLD                                       kk->pkt->pkt.secret_key->pubkey_algo,
1807 OLD                                                           sk->pubkey_usage ))
1808 OLD                          )
1809 OLD                            break;
1810 OLD                    }
1811 OLD                    if( kk ) {
1812 OLD                        u32 aki[2];
1813 OLD                        keyid_from_sk( kk->pkt->pkt.secret_key, aki );
1814 OLD                        cache_user_id( k->pkt->pkt.user_id, aki );
1815 OLD                        k = kk;
1816 OLD                        break;
1817 OLD                    }
1818 OLD                    else
1819 OLD                        log_error("No key for userid (in sk)\n");
1820 OLD                }
1821 OLD            }
1822 OLD        }
1823 OLD        else { /* keyid or fingerprint lookup */
1824 OLD            if( DBG_CACHE && (mode== 10 || mode==11) ) {
1825 OLD                log_debug("lookup_sk keyid=%08lx%08lx req_algo=%d mode=%d\n",
1826 OLD                                (ulong)keyid[0], (ulong)keyid[1],
1827 OLD                                 sk->pubkey_algo, mode );
1828 OLD            }
1829 OLD            for(k=keyblock; k; k = k->next ) {
1830 OLD                if(    k->pkt->pkttype == PKT_SECRET_KEY
1831 OLD                    || k->pkt->pkttype == PKT_SECRET_SUBKEY ) {
1832 OLD                    if( mode == 10 || mode == 11 ) {
1833 OLD                        u32 aki[2];
1834 OLD                        keyid_from_sk( k->pkt->pkt.secret_key, aki );
1835 OLD                        if( DBG_CACHE ) {
1836 OLD                            log_debug("             aki=%08lx%08lx algo=%d\n",
1837 OLD                                            (ulong)aki[0], (ulong)aki[1],
1838 OLD                                    k->pkt->pkt.secret_key->pubkey_algo    );
1839 OLD                        }
1840 OLD                        if( aki[1] == keyid[1]
1841 OLD                            && ( mode == 10 || aki[0] == keyid[0] )
1842 OLD                            && ( !sk->pubkey_algo
1843 OLD                                 || sk->pubkey_algo
1844 OLD                                    == k->pkt->pkt.secret_key->pubkey_algo) ){
1845 OLD                            /* cache the userid */
1846 OLD                            for(kk=keyblock; kk; kk = kk->next )
1847 OLD                                if( kk->pkt->pkttype == PKT_USER_ID )
1848 OLD                                    break;
1849 OLD                            if( kk )
1850 OLD                                cache_user_id( kk->pkt->pkt.user_id, aki );
1851 OLD                            else
1852 OLD                                log_error("No userid for key\n");
1853 OLD                            break; /* found */
1854 OLD                        }
1855 OLD                    }
1856 OLD                    else if( mode == 15 ) { /* get the first key */
1857 OLD                        if( !sk->pubkey_algo
1858 OLD                            || sk->pubkey_algo
1859 OLD                                  == k->pkt->pkt.secret_key->pubkey_algo )
1860 OLD                            break;
1861 OLD                    }
1862 OLD                    else if( mode == 16 || mode == 20 ) {
1863 OLD                        size_t an;
1864 OLD                        byte afp[MAX_FINGERPRINT_LEN];
1865 OLD
1866 OLD                        fingerprint_from_sk(k->pkt->pkt.secret_key, afp, &an );
1867 OLD                        if( an == mode && !memcmp( afp, name, an)
1868 OLD                            && ( !sk->pubkey_algo
1869 OLD                                 || sk->pubkey_algo
1870 OLD                                    == k->pkt->pkt.secret_key->pubkey_algo) ) {
1871 OLD                            break;
1872 OLD                        }
1873 OLD                    }
1874 OLD                    else
1875 OLD                        BUG();
1876 OLD                } /* end compare secret keys */
1877 OLD            }
1878 OLD        }
1879 OLD        if( k ) { /* found */
1880 OLD            assert(    k->pkt->pkttype == PKT_SECRET_KEY
1881 OLD                    || k->pkt->pkttype == PKT_SECRET_SUBKEY );
1882 OLD            assert( keyblock->pkt->pkttype == PKT_SECRET_KEY );
1883 OLD            if( primary && !sk->pubkey_usage )
1884 OLD                copy_secret_key( sk, keyblock->pkt->pkt.secret_key );
1885 OLD            else
1886 OLD                copy_secret_key( sk, k->pkt->pkt.secret_key );
1887 OLD            break; /* enumeration */
1888 OLD        }
1889 OLD        release_kbnode( keyblock );
1890 OLD        keyblock = NULL;
1891 OLD    }
1892 OLD    if( rc == -1 )
1893 OLD        rc = G10ERR_NO_SECKEY;
1894 OLD    else if( rc )
1895 OLD        log_error("enum_keyblocks(read) failed: %s\n", g10_errstr(rc));
1896 OLD
1897 OLD  leave:
1898 OLD    enum_keyblocks( 2, &kbpos, &keyblock ); /* close */
1899 OLD    release_kbnode( keyblock );
1900 OLD    set_packet_list_mode(oldmode);
1901 OLD    return rc;
1902 OLD}
1903 #endif
1904
1905
1906 /****************
1907  * fixme: replace by the generic function
1908  *
1909  * Enumerate all primary secret keys.  Caller must use these procedure:
1910  *  1) create a void pointer and initialize it to NULL
1911  *  2) pass this void pointer by reference to this function
1912  *     and provide space for the secret key (pass a buffer for sk)
1913  *  3) call this function as long as it does not return -1
1914  *     to indicate EOF.
1915  *  4) Always call this function a last time with SK set to NULL,
1916  *     so that can free it's context.
1917  *
1918  *
1919  */
1920 int
1921 enum_secret_keys( void **context, PKT_secret_key *sk, int with_subkeys )
1922 {
1923     int rc=0;
1924     PACKET pkt;
1925     int save_mode;
1926     struct {
1927         int eof;
1928         int sequence;
1929         const char *name;
1930         IOBUF iobuf;
1931     } *c = *context;
1932
1933
1934     if( !c ) { /* make a new context */
1935         c = m_alloc_clear( sizeof *c );
1936         *context = c;
1937         c->sequence = 0;
1938         c->name = enum_keyblock_resources( &c->sequence, 1 );
1939     }
1940
1941     if( !sk ) { /* free the context */
1942         if( c->iobuf )
1943             iobuf_close(c->iobuf);
1944         m_free( c );
1945         *context = NULL;
1946         return 0;
1947     }
1948
1949     if( c->eof )
1950         return -1;
1951
1952     /* FIXME: This assumes a plain keyring file */
1953     for( ; c->name; c->name = enum_keyblock_resources( &c->sequence, 1 ) ) {
1954         if( !c->iobuf ) {
1955             if( !(c->iobuf = iobuf_open( c->name ) ) ) {
1956                 log_error("enum_secret_keys: can't open `%s'\n", c->name );
1957                 continue; /* try next file */
1958             }
1959         }
1960
1961         save_mode = set_packet_list_mode(0);
1962         init_packet(&pkt);
1963         while( (rc=parse_packet(c->iobuf, &pkt)) != -1 ) {
1964             if( rc )
1965                 ; /* e.g. unknown packet */
1966             else if( pkt.pkttype == PKT_SECRET_KEY
1967                      || ( with_subkeys && pkt.pkttype == PKT_SECRET_SUBKEY ) ) {
1968                 copy_secret_key( sk, pkt.pkt.secret_key );
1969                 set_packet_list_mode(save_mode);
1970                 return 0; /* found */
1971             }
1972             free_packet(&pkt);
1973         }
1974         set_packet_list_mode(save_mode);
1975         iobuf_close(c->iobuf); c->iobuf = NULL;
1976     }
1977     c->eof = 1;
1978     return -1;
1979 }
1980
1981
1982 /****************
1983  * Return a string with a printable representation of the user_id.
1984  * this string must be freed by m_free.
1985  */
1986 char*
1987 get_user_id_string( u32 *keyid )
1988 {
1989     user_id_db_t r;
1990     char *p;
1991     int pass=0;
1992     /* try it two times; second pass reads from key resources */
1993     do {
1994         for(r=user_id_db; r; r = r->next )
1995             if( r->keyid[0] == keyid[0] && r->keyid[1] == keyid[1] ) {
1996                 p = m_alloc( r->len + 10 );
1997                 sprintf(p, "%08lX %.*s", (ulong)keyid[1], r->len, r->name );
1998                 return p;
1999             }
2000     } while( ++pass < 2 && !get_pubkey( NULL, keyid ) );
2001     p = m_alloc( 15 );
2002     sprintf(p, "%08lX [?]", (ulong)keyid[1] );
2003     return p;
2004 }
2005
2006 char*
2007 get_long_user_id_string( u32 *keyid )
2008 {
2009     user_id_db_t r;
2010     char *p;
2011     int pass=0;
2012     /* try it two times; second pass reads from key resources */
2013     do {
2014         for(r=user_id_db; r; r = r->next )
2015             if( r->keyid[0] == keyid[0] && r->keyid[1] == keyid[1] ) {
2016                 p = m_alloc( r->len + 20 );
2017                 sprintf(p, "%08lX%08lX %.*s",
2018                           (ulong)keyid[0], (ulong)keyid[1], r->len, r->name );
2019                 return p;
2020             }
2021     } while( ++pass < 2 && !get_pubkey( NULL, keyid ) );
2022     p = m_alloc( 25 );
2023     sprintf(p, "%08lX%08lX [?]", (ulong)keyid[0], (ulong)keyid[1] );
2024     return p;
2025 }
2026
2027 char*
2028 get_user_id( u32 *keyid, size_t *rn )
2029 {
2030     user_id_db_t r;
2031     char *p;
2032     int pass=0;
2033     /* try it two times; second pass reads from key resources */
2034     do {
2035         for(r=user_id_db; r; r = r->next )
2036             if( r->keyid[0] == keyid[0] && r->keyid[1] == keyid[1] ) {
2037                 p = m_alloc( r->len );
2038                 memcpy(p, r->name, r->len );
2039                 *rn = r->len;
2040                 return p;
2041             }
2042     } while( ++pass < 2 && !get_pubkey( NULL, keyid ) );
2043     p = m_alloc( 19 );
2044     memcpy(p, "[User id not found]", 19 );
2045     *rn = 19;
2046     return p;
2047 }
2048
2049