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