300e33b86c2ab8d667db87d3fadbd7ff7e0f8172
[gnupg.git] / g10 / getkey.c
1 /* getkey.c -  Get a key from the database
2  *      Copyright (C) 1998 Free Software Foundation, Inc.
3  *
4  * This file is part of GNUPG.
5  *
6  * GNUPG is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * GNUPG is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19  */
20
21 #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
34 #define MAX_PKC_CACHE_ENTRIES 500
35
36
37 typedef struct keyid_list {
38     struct keyid_list *next;
39     u32 keyid[2];
40 } *keyid_list_t;
41
42 typedef struct user_id_db {
43     struct user_id_db *next;
44     u32 keyid[2];
45     int len;
46     char name[1];
47 } *user_id_db_t;
48
49 typedef struct pkc_cache_entry {
50     struct pkc_cache_entry *next;
51     u32 keyid[2];
52     PKT_public_cert *pkc;
53 } *pkc_cache_entry_t;
54
55 typedef struct enum_seckey_context {
56     int eof;
57     STRLIST sl;
58     IOBUF iobuf;
59 } enum_seckey_context_t;
60
61
62 static STRLIST keyrings;
63 static STRLIST secret_keyrings;
64
65 static keyid_list_t unknown_keyids;
66 static user_id_db_t user_id_db;
67 static pkc_cache_entry_t pkc_cache;
68 static int pkc_cache_entries;   /* number of entries in pkc cache */
69
70
71 static int scan_keyring( PKT_public_cert *pkc, u32 *keyid,
72                          const char *name, const char *filename );
73 static int scan_secret_keyring( PKT_secret_cert *skc, u32 *keyid,
74                                 const char *name, const char *filename);
75
76 /* note this function may be called before secure memory is
77  * available */
78 void
79 add_keyring( const char *name )
80 {
81     STRLIST sl;
82     int rc;
83
84     /* FIXME: check wether this one is available etc */
85     /* maybe we should do this later */
86     if( *name != '/' ) { /* do tilde expansion etc */
87         char *p ;
88
89         if( strchr(name, '/') )
90             p = make_filename(name, NULL);
91         else
92             p = make_filename(opt.homedir, name, NULL);
93         sl = m_alloc( sizeof *sl + strlen(p) );
94         strcpy(sl->d, p );
95         m_free(p);
96     }
97     else {
98         sl = m_alloc( sizeof *sl + strlen(name) );
99         strcpy(sl->d, name );
100     }
101     sl->next = keyrings;
102     keyrings = sl;
103
104     /* FIXME: We should remove much out of this module and
105      * combine it with the keyblock stuff from ringedit.c
106      * For now we will simple add the filename as keyblock resource
107      */
108     rc = add_keyblock_resource( sl->d, 0, 0 );
109     if( rc )
110         log_error("keyblock resource '%s': %s\n", sl->d, g10_errstr(rc) );
111 }
112
113
114 /****************
115  * Get the name of the keyrings, start with a sequence number of 0.
116  */
117 const char *
118 get_keyring( int sequence )
119 {
120     STRLIST sl;
121
122     for(sl = keyrings; sl && sequence; sl = sl->next, sequence-- )
123         ;
124     return sl? sl->d : NULL;
125 }
126
127
128 void
129 add_secret_keyring( const char *name )
130 {
131     STRLIST sl;
132     int rc;
133
134     /* FIXME: check wether this one is available etc */
135     /* my be we should do this later */
136     if( *name != '/' ) { /* do tilde expansion etc */
137         char *p ;
138
139         if( strchr(name, '/') )
140             p = make_filename(name, NULL);
141         else
142             p = make_filename(opt.homedir, name, NULL);
143         sl = m_alloc( sizeof *sl + strlen(p) );
144         strcpy(sl->d, p );
145         m_free(p);
146     }
147     else {
148         sl = m_alloc( sizeof *sl + strlen(name) );
149         strcpy(sl->d, name );
150     }
151     sl->next = secret_keyrings;
152     secret_keyrings = sl;
153
154     /* FIXME: We should remove much out of this mpdule and
155      * combine it with the keyblock stuff from ringedit.c
156      * For now we will simple add the filename as keyblock resource
157      */
158     rc = add_keyblock_resource( sl->d, 0, 1 );
159     if( rc )
160         log_error("secret keyblock resource '%s': %s\n", sl->d, g10_errstr(rc));
161 }
162
163
164 void
165 cache_public_cert( PKT_public_cert *pkc )
166 {
167     pkc_cache_entry_t ce;
168     u32 keyid[2];
169
170     if( pkc->pubkey_algo == PUBKEY_ALGO_ELGAMAL
171         || pkc->pubkey_algo == PUBKEY_ALGO_DSA
172         || pkc->pubkey_algo == PUBKEY_ALGO_RSA ) {
173         keyid_from_pkc( pkc, keyid );
174     }
175     else
176         return; /* don't know how to get the keyid */
177
178     for( ce = pkc_cache; ce; ce = ce->next )
179         if( ce->keyid[0] == keyid[0] && ce->keyid[1] == keyid[1] ) {
180             if( DBG_CACHE )
181                 log_debug("cache_public_cert: already in cache\n");
182             return;
183         }
184
185     if( pkc_cache_entries > MAX_PKC_CACHE_ENTRIES ) {
186         /* FIMXE: use another algorithm to free some cache slots */
187         if( pkc_cache_entries == MAX_PKC_CACHE_ENTRIES )  {
188             pkc_cache_entries++;
189             log_info("too many entries in pkc cache - disabled\n");
190         }
191         ce = pkc_cache;
192         free_public_cert( ce->pkc );
193     }
194     else {
195         pkc_cache_entries++;
196         ce = m_alloc( sizeof *ce );
197         ce->next = pkc_cache;
198         pkc_cache = ce;
199     }
200     ce->pkc = copy_public_cert( NULL, pkc );
201     ce->keyid[0] = keyid[0];
202     ce->keyid[1] = keyid[1];
203 }
204
205
206 /****************
207  * Store the association of keyid and userid
208  */
209 void
210 cache_user_id( PKT_user_id *uid, u32 *keyid )
211 {
212     user_id_db_t r;
213
214     for(r=user_id_db; r; r = r->next )
215         if( r->keyid[0] == keyid[0] && r->keyid[1] == keyid[1] ) {
216             if( DBG_CACHE )
217                 log_debug("cache_user_id: already in cache\n");
218             return;
219         }
220
221     r = m_alloc( sizeof *r + uid->len-1 );
222     r->keyid[0] = keyid[0];
223     r->keyid[1] = keyid[1];
224     r->len = uid->len;
225     memcpy(r->name, uid->name, r->len);
226     r->next = user_id_db;
227     user_id_db = r;
228 }
229
230
231
232 /****************
233  * Get a public key and store it into the allocated pkc
234  * can be called with PKC set to NULL to just read it into some
235  * internal structures.
236  */
237 int
238 get_pubkey( PKT_public_cert *pkc, u32 *keyid )
239 {
240     keyid_list_t kl;
241     int internal = 0;
242     int rc = 0;
243     pkc_cache_entry_t ce;
244     STRLIST sl;
245
246
247     /* lets see wether we checked the keyid already */
248     for( kl = unknown_keyids; kl; kl = kl->next )
249         if( kl->keyid[0] == keyid[0] && kl->keyid[1] == keyid[1] )
250             return G10ERR_NO_PUBKEY; /* already checked and not found */
251
252     /* 1. Try to get it from our cache */
253     for( ce = pkc_cache; ce; ce = ce->next )
254         if( ce->keyid[0] == keyid[0] && ce->keyid[1] == keyid[1] ) {
255             if( pkc )
256                 copy_public_cert( pkc, ce->pkc );
257             return 0;
258         }
259
260     /* more init stuff */
261     if( !pkc ) {
262         pkc = m_alloc_clear( sizeof *pkc );
263         internal++;
264     }
265
266
267     /* 2. Try to get it from the keyrings */
268     for(sl = keyrings; sl; sl = sl->next )
269         if( !scan_keyring( pkc, keyid, NULL, sl->d ) )
270             goto leave;
271
272     /* 3. Try to get it from a key server */
273
274     /* 4. not found: store it for future reference */
275     kl = m_alloc( sizeof *kl );
276     kl->keyid[0] = keyid[0];
277     kl->keyid[1] = keyid[1];
278     kl->next = unknown_keyids;
279     unknown_keyids = kl;
280     rc = G10ERR_NO_PUBKEY;
281
282   leave:
283     if( !rc )
284         cache_public_cert( pkc );
285     if( internal )
286         m_free(pkc);
287     return rc;
288 }
289
290
291 /****************
292  * Try to get the pubkey by the userid. This functions looks for the
293  * first pubkey certificate which has the given name in a user_id.
294  * if pkc has the pubkey algo set, the function will only return
295  * a pubkey with that algo.
296  *
297  * - If the username starts with 8,9,16 or 17 hex-digits (the first one
298  *   must be in the range 0..9), this is considered a keyid; depending
299  *   on the length a short or complete one.
300  * - If the username starts with 32,33,40 or 41 hex-digits (the first one
301  *   must be in the range 0..9), this is considered a fingerprint.
302  *   (Not yet implemented)
303  * - If the username starts with a left angle, we assume it is a complete
304  *   email address and look only at this part.
305  * - If the userid start with an '=' an exact compare is done; this may
306  *   also follow the keyid in which case both parts are matched.
307  *   (Not yet implemented)
308  *
309  */
310 int
311 get_pubkey_byname( PKT_public_cert *pkc, const char *name )
312 {
313     int internal = 0;
314     int rc = 0;
315     STRLIST sl;
316     const char *s;
317     u32 keyid[2] = {0}; /* init to avoid compiler warning */
318     int use_keyid=0;
319
320     /* check what kind of name it is */
321     for(s = name; *s && isspace(*s); s++ )
322         ;
323     if( isdigit( *s ) ) { /* a keyid */
324         int i;
325         char buf[9];
326
327         if( *s == '0' && s[1] == 'x' && isxdigit(s[2]) )
328             s += 2; /*kludge to allow 0x034343434 */
329         for(i=0; isxdigit(s[i]); i++ )
330             ;
331         if( s[i] && !isspace(s[i]) ) /* not terminated by EOS or blank*/
332             rc = G10ERR_INV_USER_ID;
333         else if( i == 8 || (i == 9 && *s == '0') ) { /* short keyid */
334             if( i==9 )
335                 s++;
336             keyid[1] = strtoul( s, NULL, 16 );
337             use_keyid++;
338         }
339         else if( i == 16 || (i == 17 && *s == '0') ) { /* complete keyid */
340             if( i==17 )
341                 s++;
342             mem2str(buf, s, 9 );
343             keyid[0] = strtoul( buf, NULL, 16 );
344             keyid[1] = strtoul( s+8, NULL, 16 );
345             return get_pubkey( pkc, keyid );
346         }
347         else
348             rc = G10ERR_INV_USER_ID;
349     }
350     else if( *s == '<' ) { /* an email address */
351         /* for now handled like a substring */
352         /* a keyserver might use this for quicker access */
353     }
354     else if( *s == '=' ) { /* exact search */
355         rc = G10ERR_INV_USER_ID; /* nox yet implemented */
356     }
357     else if( *s == '#' ) { /* use local id */
358         rc = G10ERR_INV_USER_ID; /* nox yet implemented */
359     }
360     else if( *s == '*' ) { /* substring search */
361         name++;
362     }
363     else if( !*s )  /* empty string */
364         rc = G10ERR_INV_USER_ID;
365
366     if( rc )
367         goto leave;
368
369
370
371     if( !pkc ) {
372         pkc = m_alloc_clear( sizeof *pkc );
373         internal++;
374     }
375
376     /* 2. Try to get it from the keyrings */
377     for(sl = keyrings; sl; sl = sl->next )
378         if( use_keyid ) {
379             if( !scan_keyring( pkc, keyid, name, sl->d ) )
380                 goto leave;
381         }
382         else {
383             if( !scan_keyring( pkc, NULL, name, sl->d ) )
384                 goto leave;
385         }
386     /* 3. Try to get it from a key server */
387
388     /* 4. not found: store it for future reference */
389     rc = G10ERR_NO_PUBKEY;
390
391   leave:
392     if( internal )
393         m_free(pkc);
394     return rc;
395 }
396
397
398 /****************
399  * Get a secret key and store it into skey
400  */
401 int
402 get_seckey( PKT_secret_cert *skc, u32 *keyid )
403 {
404     STRLIST sl;
405     int rc=0;
406
407     for(sl = secret_keyrings; sl; sl = sl->next )
408         if( !(rc=scan_secret_keyring( skc, keyid, NULL, sl->d )) )
409             goto found;
410     /* fixme: look at other places */
411     goto leave;
412
413   found:
414     /* get the secret key (this may prompt for a passprase to
415      * unlock the secret key
416      */
417     if( (rc = check_secret_key( skc )) )
418         goto leave;
419
420   leave:
421     return rc;
422 }
423
424 /****************
425  * Check wether the secret key is available
426  * Returns: 0 := key is available
427  *          G10ERR_NO_SECKEY := not availabe
428  */
429 int
430 seckey_available( u32 *keyid )
431 {
432     PKT_secret_cert *skc;
433     STRLIST sl;
434     int rc=0;
435
436     skc = m_alloc_clear( sizeof *skc );
437     for(sl = secret_keyrings; sl; sl = sl->next )
438         if( !(rc=scan_secret_keyring( skc, keyid, NULL, sl->d )) )
439             goto found;
440     /* fixme: look at other places */
441     goto leave;
442
443   found:
444   leave:
445     free_secret_cert( skc );
446     return rc;
447 }
448
449
450
451 /****************
452  * Get a secret key by name and store it into skc
453  * If NAME is NULL use the default certificate
454  */
455 int
456 get_seckey_byname( PKT_secret_cert *skc, const char *name, int unprotect )
457 {
458     STRLIST sl;
459     int rc=0;
460
461     for(sl = secret_keyrings; sl; sl = sl->next )
462         if( !(rc=scan_secret_keyring( skc, NULL, name, sl->d ) ) )
463             goto found;
464     /* fixme: look at other places */
465     goto leave;
466
467   found:
468     /* get the secret key (this may prompt for a passprase to
469      * unlock the secret key
470      */
471     if( unprotect )
472         if( (rc = check_secret_key( skc )) )
473             goto leave;
474
475   leave:
476     return rc;
477 }
478
479
480
481
482
483 /****************
484  * scan the keyring and look for either the keyid or the name.
485  * If both, keyid and name are given, look for keyid but use only
486  * the low word of it (name is only used as a flag to indicate this mode
487  * of operation).
488  */
489 static int
490 scan_keyring( PKT_public_cert *pkc, u32 *keyid,
491               const char *name, const char *filename )
492 {
493     compress_filter_context_t cfx;
494     int rc=0;
495     int found = 0;
496     IOBUF a;
497     PACKET pkt;
498     int save_mode;
499     u32 akeyid[2];
500     PKT_public_cert *last_pk = NULL;
501     int shortkeyid;
502
503     shortkeyid = keyid && name;
504     if( shortkeyid )
505         name = NULL; /* not used anymore */
506
507     if( !(a = iobuf_open( filename ) ) ) {
508         log_debug("scan_keyring: can't open '%s'\n", filename );
509         return G10ERR_KEYRING_OPEN;
510     }
511
512     if( !DBG_CACHE )
513         ;
514     else if( shortkeyid )
515         log_debug("scan_keyring %s for %08lx\n",  filename, (ulong)keyid[1] );
516     else if( name )
517         log_debug("scan_keyring %s for '%s'\n",  filename, name );
518     else if( keyid )
519         log_debug("scan_keyring %s for %08lx %08lx\n",  filename,
520                                              (ulong)keyid[0], (ulong)keyid[1] );
521     else
522         log_debug("scan_keyring %s (all)\n",  filename );
523
524     save_mode = set_packet_list_mode(0);
525     init_packet(&pkt);
526     while( (rc=parse_packet(a, &pkt)) != -1 ) {
527         if( rc )
528             ; /* e.g. unknown packet */
529         else if( keyid && found && pkt.pkttype == PKT_PUBLIC_CERT ) {
530             log_error("Hmmm, pubkey without an user id in '%s'\n", filename);
531             goto leave;
532         }
533         else if( pkt.pkttype == PKT_COMPRESSED ) {
534             memset( &cfx, 0, sizeof cfx );
535             if( pkt.pkt.compressed->algorithm == 1 )
536                 cfx.pgpmode = 1;
537             else if( pkt.pkt.compressed->algorithm != 2  ){
538                 rc = G10ERR_COMPR_ALGO;
539                 log_error("compressed keyring: %s\n", g10_errstr(rc) );
540                 break;
541             }
542
543             pkt.pkt.compressed->buf = NULL;
544             iobuf_push_filter( a, compress_filter, &cfx );
545         }
546         else if( keyid && pkt.pkttype == PKT_PUBLIC_CERT ) {
547             switch( pkt.pkt.public_cert->pubkey_algo ) {
548               case PUBKEY_ALGO_ELGAMAL:
549               case PUBKEY_ALGO_DSA:
550               case PUBKEY_ALGO_RSA:
551                 keyid_from_pkc( pkt.pkt.public_cert, akeyid );
552                 if( (shortkeyid || akeyid[0] == keyid[0])
553                     && akeyid[1] == keyid[1] ) {
554                     copy_public_cert( pkc, pkt.pkt.public_cert );
555                     found++;
556                 }
557                 break;
558               default:
559                 log_error("cannot handle pubkey algo %d\n",
560                                      pkt.pkt.public_cert->pubkey_algo);
561             }
562         }
563         else if( keyid && found && pkt.pkttype == PKT_USER_ID ) {
564             cache_user_id( pkt.pkt.user_id, keyid );
565             goto leave;
566         }
567         else if( name && pkt.pkttype == PKT_PUBLIC_CERT ) {
568             if( last_pk )
569                 free_public_cert(last_pk);
570             last_pk = pkt.pkt.public_cert;
571             pkt.pkt.public_cert = NULL;
572         }
573         else if( name && pkt.pkttype == PKT_USER_ID ) {
574             if( memistr( pkt.pkt.user_id->name, pkt.pkt.user_id->len, name )) {
575                 if( !last_pk )
576                     log_error("Ooops: no pubkey for userid '%.*s'\n",
577                                 pkt.pkt.user_id->len, pkt.pkt.user_id->name);
578                 else if( pkc->pubkey_algo &&
579                          pkc->pubkey_algo != last_pk->pubkey_algo )
580                     log_info("skipping id '%.*s': want algo %d, found %d\n",
581                                 pkt.pkt.user_id->len, pkt.pkt.user_id->name,
582                                 pkc->pubkey_algo, last_pk->pubkey_algo );
583                 else {
584                     copy_public_cert( pkc, last_pk );
585                     goto leave;
586                 }
587             }
588         }
589         else if( !keyid && !name && pkt.pkttype == PKT_PUBLIC_CERT ) {
590             if( last_pk )
591                 free_public_cert(last_pk);
592             last_pk = pkt.pkt.public_cert;
593             pkt.pkt.public_cert = NULL;
594         }
595         else if( !keyid && !name && pkt.pkttype == PKT_USER_ID ) {
596             if( !last_pk )
597                 log_error("Ooops: no pubkey for userid '%.*s'\n",
598                             pkt.pkt.user_id->len, pkt.pkt.user_id->name);
599             else {
600                 if( last_pk->pubkey_algo == PUBKEY_ALGO_ELGAMAL
601                     || last_pk->pubkey_algo == PUBKEY_ALGO_DSA
602                     || last_pk->pubkey_algo == PUBKEY_ALGO_RSA ) {
603                      keyid_from_pkc( last_pk, akeyid );
604                      cache_user_id( pkt.pkt.user_id, akeyid );
605                 }
606                 cache_public_cert( last_pk );
607             }
608         }
609         free_packet(&pkt);
610     }
611     rc = G10ERR_NO_PUBKEY;
612
613   leave:
614     if( last_pk )
615         free_public_cert(last_pk);
616     free_packet(&pkt);
617     iobuf_close(a);
618     set_packet_list_mode(save_mode);
619     return rc;
620 }
621
622
623 /****************
624  * This is the function to get a secret key. We use an extra function,
625  * so that we can easily add special handling for secret keyrings
626  * PKT returns the secret key certificate.
627  */
628 static int
629 scan_secret_keyring( PKT_secret_cert *skc, u32 *keyid,
630                      const char *name, const char *filename )
631 {
632     int rc=0;
633     int found = 0;
634     IOBUF a;
635     PACKET pkt;
636     int save_mode;
637     u32 akeyid[2];
638     PKT_secret_cert *last_pk = NULL;
639     int get_first;
640     u32 dummy_keyid[2];
641
642     get_first = !keyid && !name;
643     if( get_first )
644         keyid = dummy_keyid;
645
646     if( !(a = iobuf_open( filename ) ) ) {
647         log_debug("scan_secret_keyring: can't open '%s'\n", filename );
648         return G10ERR_KEYRING_OPEN;
649     }
650
651     save_mode = set_packet_list_mode(0);
652     init_packet(&pkt);
653     while( (rc=parse_packet(a, &pkt)) != -1 ) {
654         if( rc )
655             ; /* e.g. unknown packet */
656         else if( keyid && found && pkt.pkttype == PKT_SECRET_CERT ) {
657             log_error("Hmmm, seckey without an user id in '%s'\n", filename);
658             goto leave;
659         }
660         else if( keyid && pkt.pkttype == PKT_SECRET_CERT ) {
661             switch( pkt.pkt.secret_cert->pubkey_algo ) {
662               case PUBKEY_ALGO_ELGAMAL:
663               case PUBKEY_ALGO_DSA:
664               case PUBKEY_ALGO_RSA:
665                 if( get_first ) {
666                     copy_secret_cert( skc, pkt.pkt.secret_cert );
667                     found++;
668                 }
669                 else {
670                     keyid_from_skc( pkt.pkt.secret_cert, akeyid );
671                     if( (akeyid[0] == keyid[0] && akeyid[1] == keyid[1]) ) {
672                         copy_secret_cert( skc, pkt.pkt.secret_cert );
673                         found++;
674                     }
675                 }
676                 break;
677               default:
678                 log_error("cannot handle pubkey algo %d\n",
679                                      pkt.pkt.secret_cert->pubkey_algo);
680             }
681         }
682         else if( keyid && found && pkt.pkttype == PKT_USER_ID ) {
683             goto leave;
684         }
685         else if( name && pkt.pkttype == PKT_SECRET_CERT ) {
686             if( last_pk )
687                 free_secret_cert(last_pk);
688             last_pk = pkt.pkt.secret_cert;
689             pkt.pkt.secret_cert = NULL;
690         }
691         else if( name && pkt.pkttype == PKT_USER_ID ) {
692             if( memistr( pkt.pkt.user_id->name, pkt.pkt.user_id->len, name )) {
693                 if( !last_pk )
694                     log_error("Ooops: no seckey for userid '%.*s'\n",
695                                 pkt.pkt.user_id->len, pkt.pkt.user_id->name);
696                 else if( skc->pubkey_algo &&
697                          skc->pubkey_algo != last_pk->pubkey_algo )
698                     log_info("skipping id '%.*s': want algo %d, found %d\n",
699                                 pkt.pkt.user_id->len, pkt.pkt.user_id->name,
700                                 skc->pubkey_algo, last_pk->pubkey_algo );
701                 else {
702                     copy_secret_cert( skc, last_pk );
703                     goto leave;
704                 }
705             }
706         }
707         else if( !keyid && !name && pkt.pkttype == PKT_SECRET_CERT ) {
708             if( last_pk )
709                 free_secret_cert(last_pk);
710             last_pk = pkt.pkt.secret_cert;
711             pkt.pkt.secret_cert = NULL;
712         }
713         else if( !keyid && !name && pkt.pkttype == PKT_USER_ID ) {
714             if( !last_pk )
715                 log_error("Ooops: no seckey for userid '%.*s'\n",
716                             pkt.pkt.user_id->len, pkt.pkt.user_id->name);
717             else {
718                 if( last_pk->pubkey_algo == PUBKEY_ALGO_ELGAMAL
719                    || last_pk->pubkey_algo == PUBKEY_ALGO_DSA
720                    || last_pk->pubkey_algo == PUBKEY_ALGO_RSA ) {
721                     keyid_from_skc( last_pk, akeyid );
722                     cache_user_id( pkt.pkt.user_id, akeyid );
723                 }
724             }
725         }
726         free_packet(&pkt);
727     }
728     rc = G10ERR_NO_SECKEY;
729
730   leave:
731     if( last_pk )
732         free_secret_cert(last_pk);
733     free_packet(&pkt);
734     iobuf_close(a);
735     set_packet_list_mode(save_mode);
736     return rc;
737 }
738
739
740 /****************
741  * Enumerate all secret keys.  Caller must use these procedure:
742  *  1) create a void pointer and initialize it to NULL
743  *  2) pass this void pointer by reference to this function
744  *     and provide space for the secret key (pass a buffer for skc)
745  *  3) call this function as long as it does not return -1
746  *     to indicate EOF.
747  *  4) Always call this function a last time with SKC set to NULL,
748  *     so that can free it's context.
749  *
750  * Return
751  */
752 int
753 enum_secret_keys( void **context, PKT_secret_cert *skc )
754 {
755     int rc=0;
756     PACKET pkt;
757     int save_mode;
758     enum_seckey_context_t *c = *context;
759
760     if( !c ) { /* make a new context */
761         c = m_alloc_clear( sizeof *c );
762         *context = c;
763         c->sl = secret_keyrings;
764     }
765
766     if( !skc ) { /* free the context */
767         m_free( c );
768         *context = NULL;
769         return 0;
770     }
771
772     if( c->eof )
773         return -1;
774
775     for( ; c->sl; c->sl = c->sl->next ) {
776         if( !c->iobuf ) {
777             if( !(c->iobuf = iobuf_open( c->sl->d ) ) ) {
778                 log_error("enum_secret_keys: can't open '%s'\n", c->sl->d );
779                 continue; /* try next file */
780             }
781         }
782
783         save_mode = set_packet_list_mode(0);
784         init_packet(&pkt);
785         while( (rc=parse_packet(c->iobuf, &pkt)) != -1 ) {
786             if( rc )
787                 ; /* e.g. unknown packet */
788             else if( pkt.pkttype == PKT_SECRET_CERT ) {
789                 copy_secret_cert( skc, pkt.pkt.secret_cert );
790                 set_packet_list_mode(save_mode);
791                 return 0; /* found */
792             }
793             free_packet(&pkt);
794         }
795         set_packet_list_mode(save_mode);
796         iobuf_close(c->iobuf); c->iobuf = NULL;
797     }
798     c->eof = 1;
799     return -1;
800 }
801
802
803 /****************
804  * Return a string with a printable representation of the user_id.
805  * this string must be freed by m_free.
806  */
807 char*
808 get_user_id_string( u32 *keyid )
809 {
810     user_id_db_t r;
811     char *p;
812     int pass=0;
813     /* try it two times; second pass reads from keyrings */
814     do {
815         for(r=user_id_db; r; r = r->next )
816             if( r->keyid[0] == keyid[0] && r->keyid[1] == keyid[1] ) {
817                 p = m_alloc( r->len + 10 );
818                 sprintf(p, "%08lX %.*s", (ulong)keyid[1], r->len, r->name );
819                 return p;
820             }
821     } while( ++pass < 2 && !get_pubkey( NULL, keyid ) );
822     p = m_alloc( 15 );
823     sprintf(p, "%08lX [?]", (ulong)keyid[1] );
824     return p;
825 }
826
827 char*
828 get_user_id( u32 *keyid, size_t *rn )
829 {
830     user_id_db_t r;
831     char *p;
832     int pass=0;
833     /* try it two times; second pass reads from keyrings */
834     do {
835         for(r=user_id_db; r; r = r->next )
836             if( r->keyid[0] == keyid[0] && r->keyid[1] == keyid[1] ) {
837                 p = m_alloc( r->len );
838                 memcpy(p, r->name, r->len );
839                 *rn = r->len;
840                 return p;
841             }
842     } while( ++pass < 2 && !get_pubkey( NULL, keyid ) );
843     p = m_alloc( 19 );
844     memcpy(p, "[User id not found]", 19 );
845     *rn = 19;
846     return p;
847 }
848
849