Some bug fixes of the last release
[gnupg.git] / g10 / ringedit.c
1 /* ringedit.c -  Function for key ring editing
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
22 /****************
23  * This module supplies function for:
24  *
25  *  - Search for a key block (pubkey and all other stuff) and return a
26  *    handle for it.
27  *
28  *  - Lock/Unlock a key block
29  *
30  *  - Read a key block into a tree
31  *
32  *  - Update a key block
33  *
34  *  - Insert a new key block
35  *
36  *  - Delete a key block
37  *
38  */
39
40
41
42 #include <config.h>
43 #include <stdio.h>
44 #include <stdlib.h>
45 #include <string.h>
46 #include <errno.h>
47 #include <sys/types.h>
48 #include <sys/stat.h>
49 #include <unistd.h> /* for truncate */
50 #include <assert.h>
51 #ifdef HAVE_LIBGDBM
52   #include <gdbm.h>
53 #endif
54 #include "util.h"
55 #include "packet.h"
56 #include "memory.h"
57 #include "mpi.h"
58 #include "iobuf.h"
59 #include "keydb.h"
60 #include "host2net.h"
61 #include "options.h"
62 #include "main.h"
63 #include "i18n.h"
64
65
66 struct resource_table_struct {
67     int used;
68     int secret; /* this is a secret keyring */
69     char *fname;
70     IOBUF iobuf;
71   #ifdef HAVE_LIBGDBM
72     GDBM_FILE dbf;
73   #endif
74     enum resource_type rt;
75 };
76 typedef struct resource_table_struct RESTBL;
77
78 #define MAX_RESOURCES 10
79 static RESTBL resource_table[MAX_RESOURCES];
80
81 static int search( PACKET *pkt, KBPOS *kbpos, int secret );
82
83
84 static int keyring_search( PACKET *pkt, KBPOS *kbpos, IOBUF iobuf,
85                                                 const char *fname );
86 static int keyring_read( KBPOS *kbpos, KBNODE *ret_root );
87 static int keyring_enum( KBPOS *kbpos, KBNODE *ret_root, int skipsigs );
88 static int keyring_copy( KBPOS *kbpos, int mode, KBNODE root );
89
90 #ifdef HAVE_LIBGDBM
91 static int do_gdbm_store( KBPOS *kbpos, KBNODE root, int update );
92 static int do_gdbm_locate( GDBM_FILE dbf, KBPOS *kbpos,
93                                           const byte *fpr, int fprlen );
94 static int do_gdbm_locate_by_keyid( GDBM_FILE dbf, KBPOS *kbpos, u32 *keyid );
95 static int do_gdbm_read( KBPOS *kbpos, KBNODE *ret_root );
96 static int do_gdbm_enum( KBPOS *kbpos, KBNODE *ret_root );
97 #endif
98
99
100 static RESTBL *
101 check_pos( KBPOS *kbpos )
102 {
103     if( kbpos->resno < 0 || kbpos->resno >= MAX_RESOURCES )
104         return NULL;
105     if( !resource_table[kbpos->resno].used )
106         return NULL;
107     return resource_table + kbpos->resno;
108 }
109
110 #ifdef HAVE_LIBGDBM
111 static void
112 fatal_gdbm_error( const char *string )
113 {
114     log_fatal("gdbm failed: %s\n", string);
115 }
116
117 #endif /* HAVE_LIBGDBM */
118
119 /****************************************************************
120  ****************** public functions ****************************
121  ****************************************************************/
122
123 /****************
124  * Get the name of the keyrings, start with a sequence number pointing to a 0.
125  */
126 const char *
127 enum_keyblock_resources( int *sequence, int secret )
128 {
129     int i = *sequence;
130     const char *name = NULL;
131
132     for(; i < MAX_RESOURCES; i++ )
133         if( resource_table[i].used && !resource_table[i].secret == !secret ) {
134             if( resource_table[i].fname ) {
135                 name = resource_table[i].fname;
136                 break;
137             }
138         }
139     *sequence = ++i;
140     return name;
141 }
142
143
144
145 /****************
146  * Register a resource (which currently may only be a keyring file).
147  * The first keyring which is added by this function is
148  * created if it does not exist.
149  * Note: this function may be called before secure memory is
150  * available.
151  */
152 int
153 add_keyblock_resource( const char *url, int force, int secret )
154 {
155     static int any_secret, any_public;
156     const char *resname = url;
157     IOBUF iobuf = NULL;
158     int i;
159     char *filename = NULL;
160     int rc = 0;
161     enum resource_type rt = rt_UNKNOWN;
162
163     /* Do we have an URL?
164      *  gnupg-gdbm:filename  := this is a GDBM resource
165      *  gnupg-ring:filename  := this is a plain keyring
166      *  filename := See what is is, but create as plain keyring.
167      */
168     if( strlen( resname ) > 11 ) {
169         if( !strncmp( resname, "gnupg-ring:", 11 ) ) {
170             rt = rt_RING;
171             resname += 11;
172         }
173         else if( !strncmp( resname, "gnupg-gdbm:", 11 ) ) {
174             rt = rt_GDBM;
175             resname += 11;
176         }
177       #ifndef __MINGW32__
178         else if( strchr( resname, ':' ) ) {
179             log_error("%s: invalid URL\n", url );
180             rc = G10ERR_GENERAL;
181             goto leave;
182         }
183       #endif
184     }
185
186     if( *resname != '/' ) { /* do tilde expansion etc */
187         if( strchr(resname, '/') )
188             filename = make_filename(resname, NULL);
189         else
190             filename = make_filename(opt.homedir, resname, NULL);
191     }
192     else
193         filename = m_strdup( resname );
194
195     if( !force )
196         force = secret? !any_secret : !any_public;
197
198     for(i=0; i < MAX_RESOURCES; i++ )
199         if( !resource_table[i].used )
200             break;
201     if( i == MAX_RESOURCES ) {
202         rc = G10ERR_RESOURCE_LIMIT;
203         goto leave;
204     }
205
206     /* see whether we can determine the filetype */
207     if( rt == rt_UNKNOWN ) {
208         FILE *fp = fopen( filename, "rb" );
209
210         if( fp ) {
211             u32 magic;
212
213             if( fread( &magic, 4, 1, fp) == 1 ) {
214                 if( magic == 0x13579ace )
215                     rt = rt_GDBM;
216                 else if( magic == 0xce9a5713 )
217                     log_error("%s: endianess does not match\n", url );
218                 else
219                     rt = rt_RING;
220             }
221             else /* maybe empty: assume ring */
222                 rt = rt_RING;
223             fclose( fp );
224         }
225         else /* no file yet: create ring */
226             rt = rt_RING;
227     }
228
229     switch( rt ) {
230       case rt_UNKNOWN:
231         log_error("%s: unknown resource type\n", url );
232         rc = G10ERR_GENERAL;
233         goto leave;
234
235       case rt_RING:
236         iobuf = iobuf_fopen( filename, "rb" );
237         if( !iobuf && !force ) {
238             rc = G10ERR_OPEN_FILE;
239             goto leave;
240         }
241
242         if( !iobuf ) {
243             char *last_slash_in_filename;
244
245             last_slash_in_filename = strrchr(filename, '/');
246             *last_slash_in_filename = 0;
247
248             if( access(filename, F_OK) ) {
249                 if( strlen(filename) >= 7
250                     && !strcmp(filename+strlen(filename)-7, "/.gnupg") ) {
251                   #if __MINGW32__
252                     if( mkdir(filename) )
253                   #else
254                     if( mkdir(filename, S_IRUSR|S_IWUSR|S_IXUSR) )
255                   #endif
256                     {
257                         log_error( _("%s: can't create directory: %s\n"),
258                                   filename, strerror(errno));
259                         rc = G10ERR_OPEN_FILE;
260                         goto leave;
261                     }
262                     else
263                         log_info( _("%s: directory created\n"), filename );
264                     copy_options_file( filename );
265                 }
266                 else
267                 {
268                     rc = G10ERR_OPEN_FILE;
269                     goto leave;
270                 }
271             }
272
273             *last_slash_in_filename = '/';
274
275             iobuf = iobuf_create( filename );
276             if( !iobuf ) {
277                 log_error(_("%s: can't create keyring: %s\n"),
278                                             filename, strerror(errno));
279                 rc = G10ERR_OPEN_FILE;
280                 goto leave;
281             }
282             else
283                 log_info(_("%s: keyring created\n"), filename );
284         }
285       #ifdef __MINGW32__
286         /* must close it again */
287         iobuf_close( iobuf );
288         iobuf = NULL;
289       #endif
290         break;
291
292     #ifdef HAVE_LIBGDBM
293       case rt_GDBM:
294         resource_table[i].dbf = gdbm_open( filename, 0,
295                                            force? GDBM_WRCREAT : GDBM_WRITER,
296                                            S_IRUSR | S_IWUSR |
297                                            S_IRGRP | S_IWGRP | S_IROTH,
298                                            fatal_gdbm_error );
299         if( !resource_table[i].dbf ) {
300             log_error("%s: can't open gdbm file: %s\n",
301                             filename, gdbm_strerror(gdbm_errno));
302             rc = G10ERR_OPEN_FILE;
303             goto leave;
304         }
305         break;
306     #endif
307
308       default:
309         log_error("%s: unsupported resource type\n", url );
310         rc = G10ERR_GENERAL;
311         goto leave;
312     }
313
314     resource_table[i].used = 1;
315     resource_table[i].secret = !!secret;
316     resource_table[i].fname = m_strdup(filename);
317     resource_table[i].iobuf = iobuf;
318     resource_table[i].rt    = rt;
319   leave:
320     if( rc )
321         log_error("keyblock resource '%s': %s\n", filename, g10_errstr(rc) );
322     else if( secret )
323         any_secret = 1;
324     else
325         any_public = 1;
326     m_free( filename );
327     return rc;
328 }
329
330 /****************
331  * Return the resource name of the keyblock associated with KBPOS.
332  */
333 const char *
334 keyblock_resource_name( KBPOS *kbpos )
335 {
336     RESTBL *rentry;
337
338     if( !(rentry = check_pos( kbpos )) || !rentry->fname )
339         log_bug("no name for keyblock resource %d\n", kbpos->resno );
340     return rentry->fname;
341 }
342
343
344 /****************
345  * Get a keyblock handle KBPOS from a filename. This can be used
346  * to get a handle for insert_keyblock for a new keyblock.
347  * Using a filename of NULL returns the default resource
348  */
349 int
350 get_keyblock_handle( const char *filename, int secret, KBPOS *kbpos )
351 {
352     int i;
353
354     for(i=0; i < MAX_RESOURCES; i++ )
355         if( resource_table[i].used && !resource_table[i].secret == !secret ) {
356             /* fixme: dos needs case insensitive file compare */
357             if( !filename || !strcmp( resource_table[i].fname, filename ) ) {
358                 memset( kbpos, 0, sizeof *kbpos );
359                 kbpos->resno = i;
360                 kbpos->rt = resource_table[i].rt;
361                 return 0;
362             }
363         }
364     return -1; /* not found */
365 }
366
367
368
369 /****************
370  * Search a keyblock which starts with the given packet and puts all
371  * information into KBPOS, which can be used later to access this key block.
372  * This function looks into all registered keyblock sources.
373  * PACKET must be a packet with either a secret_key or a public_key
374  *
375  * This function is intended to check whether a given certificate
376  * is already in a keyring or to prepare it for editing.
377  *
378  * Returns: 0 if found, -1 if not found or an errorcode.
379  */
380 static int
381 search( PACKET *pkt, KBPOS *kbpos, int secret )
382 {
383     int i, rc, last_rc=-1;
384
385     for(i=0; i < MAX_RESOURCES; i++ ) {
386         if( resource_table[i].used && !resource_table[i].secret == !secret ) {
387             switch( resource_table[i].rt ) {
388               case rt_RING:
389                 rc = keyring_search( pkt, kbpos, resource_table[i].iobuf,
390                                                  resource_table[i].fname );
391                 break;
392              #ifdef HAVE_LIBGDBM
393               case rt_GDBM: {
394                     PKT_public_key *req_pk = pkt->pkt.public_key;
395                     byte fpr[20];
396                     size_t fprlen;
397
398                     fingerprint_from_pk( req_pk, fpr, &fprlen );
399                     rc = do_gdbm_locate( resource_table[i].dbf,
400                                          kbpos, fpr, fprlen );
401                 }
402                 break;
403              #endif
404               default: BUG();
405             }
406
407             kbpos->rt = resource_table[i].rt;
408             if( !rc ) {
409                 kbpos->resno = i;
410                 kbpos->fp = NULL;
411                 return 0;
412             }
413             if( rc != -1 ) {
414                 log_error("error searching resource %d: %s\n",
415                                                   i, g10_errstr(rc));
416                 last_rc = rc;
417             }
418         }
419     }
420     return last_rc;
421 }
422
423
424 /****************
425  * Combined function to search for a username and get the position
426  * of the keyblock.
427  */
428 int
429 find_keyblock_byname( KBPOS *kbpos, const char *username )
430 {
431     PACKET pkt;
432     PKT_public_key *pk = m_alloc_clear( sizeof *pk );
433     int rc;
434
435     rc = get_pubkey_byname( NULL, pk, username, NULL );
436     if( rc ) {
437         free_public_key(pk);
438         return rc;
439     }
440
441     init_packet( &pkt );
442     pkt.pkttype = PKT_PUBLIC_KEY;
443     pkt.pkt.public_key = pk;
444     rc = search( &pkt, kbpos, 0 );
445     free_public_key(pk);
446     return rc;
447 }
448
449
450 /****************
451  * Combined function to search for a key and get the position
452  * of the keyblock.
453  */
454 int
455 find_keyblock_bypk( KBPOS *kbpos, PKT_public_key *pk )
456 {
457     PACKET pkt;
458     int rc;
459
460     init_packet( &pkt );
461     pkt.pkttype = PKT_PUBLIC_KEY;
462     pkt.pkt.public_key = pk;
463     rc = search( &pkt, kbpos, 0 );
464     return rc;
465 }
466
467
468 /****************
469  * Combined function to search for a username and get the position
470  * of the keyblock. This function does not unprotect the secret key.
471  */
472 int
473 find_secret_keyblock_byname( KBPOS *kbpos, const char *username )
474 {
475     PACKET pkt;
476     PKT_secret_key *sk = m_alloc_clear( sizeof *sk );
477     int rc;
478
479     rc = get_seckey_byname( sk, username, 0 );
480     if( rc ) {
481         free_secret_key(sk);
482         return rc;
483     }
484
485     init_packet( &pkt );
486     pkt.pkttype = PKT_SECRET_KEY;
487     pkt.pkt.secret_key = sk;
488     rc = search( &pkt, kbpos, 1 );
489     free_secret_key(sk);
490     return rc;
491 }
492
493
494 /****************
495  * Locate a keyblock in a database which is capable of direct access
496  * Put all information into KBPOS, which can be later be to access this
497  * key block.
498  * This function looks into all registered keyblock sources.
499  *
500  * Returns: 0 if found,
501  *          -1 if not found
502  *          G10ERR_UNSUPPORTED if no resource is able to handle this
503  *          or another errorcode.
504  */
505 int
506 locate_keyblock_by_fpr( KBPOS *kbpos, const byte *fpr, int fprlen, int secret )
507 {
508     RESTBL *rentry;
509     int i, rc, any=0, last_rc=-1;
510
511
512     for(i=0, rentry = resource_table; i < MAX_RESOURCES; i++, rentry++ ) {
513         if( rentry->used && !rentry->secret == !secret ) {
514             kbpos->rt = rentry->rt;
515             switch( rentry->rt ) {
516              #ifdef HAVE_LIBGDBM
517               case rt_GDBM:
518                 any = 1;
519                 rc = do_gdbm_locate( rentry->dbf, kbpos, fpr, fprlen );
520                 break;
521              #endif
522               default:
523                 rc = G10ERR_UNSUPPORTED;
524                 break;
525             }
526
527             if( !rc ) {
528                 kbpos->resno = i;
529                 kbpos->fp = NULL;
530                 return 0;
531             }
532             else if( rc != -1 && rc != G10ERR_UNSUPPORTED ) {
533                 log_error("error searching resource %d: %s\n",
534                                                   i, g10_errstr(rc));
535                 last_rc = rc;
536             }
537         }
538     }
539
540     return (last_rc == -1 && !any)? G10ERR_UNSUPPORTED : last_rc;
541 }
542
543
544 int
545 locate_keyblock_by_keyid( KBPOS *kbpos, u32 *keyid, int shortkid, int secret )
546 {
547     RESTBL *rentry;
548     int i, rc, any=0, last_rc=-1;
549
550     if( shortkid )
551         return G10ERR_UNSUPPORTED;
552
553     for(i=0, rentry = resource_table; i < MAX_RESOURCES; i++, rentry++ ) {
554         if( rentry->used && !rentry->secret == !secret ) {
555             kbpos->rt = rentry->rt;
556             switch( rentry->rt ) {
557              #ifdef HAVE_LIBGDBM
558               case rt_GDBM:
559                 any = 1;
560                 rc = do_gdbm_locate_by_keyid( rentry->dbf, kbpos, keyid );
561                 break;
562              #endif
563               default:
564                 rc = G10ERR_UNSUPPORTED;
565                 break;
566             }
567
568             if( !rc ) {
569                 kbpos->resno = i;
570                 kbpos->fp = NULL;
571                 return 0;
572             }
573             else if( rc != -1 && rc != G10ERR_UNSUPPORTED ) {
574                 log_error("error searching resource %d: %s\n",
575                                                   i, g10_errstr(rc));
576                 last_rc = rc;
577             }
578         }
579     }
580
581     return (last_rc == -1 && !any)? G10ERR_UNSUPPORTED : last_rc;
582 }
583
584
585
586
587 /****************
588  * Lock the keyblock; wait until it's available
589  * This function may change the internal data in kbpos, in cases
590  * when the keyblock to be locked has been modified.
591  * fixme: remove this function and add an option to search()?
592  */
593 int
594 lock_keyblock( KBPOS *kbpos )
595 {
596     if( !check_pos(kbpos) )
597         return G10ERR_GENERAL;
598     return 0;
599 }
600
601 /****************
602  * Release a lock on a keyblock
603  */
604 void
605 unlock_keyblock( KBPOS *kbpos )
606 {
607     if( !check_pos(kbpos) )
608         BUG();
609 }
610
611 /****************
612  * Read a complete keyblock and return the root in ret_root.
613  */
614 int
615 read_keyblock( KBPOS *kbpos, KBNODE *ret_root )
616 {
617     if( !check_pos(kbpos) )
618         return G10ERR_GENERAL;
619
620     switch( kbpos->rt ) {
621       case rt_RING:
622         return keyring_read( kbpos, ret_root );
623      #ifdef HAVE_LIBGDBM
624       case rt_GDBM:
625         return do_gdbm_read( kbpos, ret_root );
626      #endif
627       default: BUG();
628     }
629 }
630
631
632 /****************
633  * This functions can be used to read through a complete keyring.
634  * Mode is: 0 = open
635  *          1 = read
636  *          2 = close
637  *          5 = open secret keyrings
638  *          11 = read but skip signature and comment packets.
639  *          all others are reserved!
640  * Note that you do not need a search prior to this function,
641  * only a handle is needed.
642  * NOTE: It is not allowed to do an insert/update/delete with this
643  *       keyblock, if you want to do this, use search/read!
644  */
645 int
646 enum_keyblocks( int mode, KBPOS *kbpos, KBNODE *ret_root )
647 {
648     int rc = 0;
649     RESTBL *rentry;
650
651     if( !mode || mode == 5 || mode == 100 ) {
652         int i;
653         kbpos->fp = NULL;
654         if( !mode ) {
655             kbpos->secret = 0;
656             i = 0;
657         }
658         else if( mode == 5 ) {
659             kbpos->secret = 1;
660             mode = 0;
661             i = 0;
662         }
663         else
664             i = kbpos->resno+1;
665         for(; i < MAX_RESOURCES; i++ )
666             if( resource_table[i].used
667                 && !resource_table[i].secret == !kbpos->secret )
668                 break;
669         if( i == MAX_RESOURCES )
670             return -1; /* no resources */
671         kbpos->resno = i;
672         rentry = check_pos( kbpos );
673         kbpos->rt = resource_table[i].rt;
674         switch( kbpos->rt ) {
675           case rt_RING:
676             kbpos->fp = iobuf_fopen( rentry->fname, "rb" );
677             if( !kbpos->fp ) {
678                 log_error("can't open '%s'\n", rentry->fname );
679                 return G10ERR_OPEN_FILE;
680             }
681             break;
682          #ifdef HAVE_LIBGDBM
683           case rt_GDBM:
684             /* FIXME: make sure that there is only one enum at a time */
685             kbpos->offset = 0;
686             break;
687          #endif
688           default: BUG();
689         }
690         kbpos->pkt = NULL;
691     }
692     else if( mode == 1 || mode == 11 ) {
693         int cont;
694         do {
695             cont = 0;
696             switch( kbpos->rt ) {
697               case rt_RING:
698                 if( !kbpos->fp )
699                     return G10ERR_GENERAL;
700                 rc = keyring_enum( kbpos, ret_root, mode == 11 );
701                 break;
702              #ifdef HAVE_LIBGDBM
703               case rt_GDBM:
704                 rc = do_gdbm_enum( kbpos, ret_root );
705                 break;
706              #endif
707               default: BUG();
708             }
709
710             if( rc == -1 ) {
711                 assert( !kbpos->pkt );
712                 rentry = check_pos( kbpos );
713                 assert(rentry);
714                 /* close */
715                 enum_keyblocks(2, kbpos, ret_root );
716                 /* and open the next one */
717                 rc = enum_keyblocks(100, kbpos, ret_root );
718                 if( !rc )
719                     cont = 1;
720             }
721         } while(cont);
722     }
723     else {
724         switch( kbpos->rt ) {
725           case rt_RING:
726             if( kbpos->fp ) {
727                 iobuf_close( kbpos->fp );
728                 kbpos->fp = NULL;
729             }
730             break;
731           case rt_GDBM:
732             break;
733           default:
734             log_error("OOPS in close enum_keyblocks - ignored\n");
735             return rc;
736             break;
737         }
738         /* release pending packet */
739         free_packet( kbpos->pkt );
740         m_free( kbpos->pkt );
741     }
742     return rc;
743 }
744
745
746
747
748 /****************
749  * Insert the keyblock described by ROOT into the keyring described
750  * by KBPOS.  This actually appends the data to the keyfile.
751  */
752 int
753 insert_keyblock( KBPOS *kbpos, KBNODE root )
754 {
755     int rc;
756
757     if( !check_pos(kbpos) )
758         return G10ERR_GENERAL;
759
760     switch( kbpos->rt ) {
761       case rt_RING:
762         rc = keyring_copy( kbpos, 1, root );
763         break;
764      #ifdef HAVE_LIBGDBM
765       case rt_GDBM:
766         rc = do_gdbm_store( kbpos, root, 0 );
767         break;
768      #endif
769       default: BUG();
770     }
771
772     return rc;
773 }
774
775 /****************
776  * Delete the keyblock described by KBPOS.
777  * The current code simply changes the keyblock in the keyring
778  * to packet of type 0 with the correct length.  To help detect errors,
779  * zero bytes are written.
780  */
781 int
782 delete_keyblock( KBPOS *kbpos )
783 {
784     int rc;
785
786     if( !check_pos(kbpos) )
787         return G10ERR_GENERAL;
788
789     switch( kbpos->rt ) {
790       case rt_RING:
791         rc = keyring_copy( kbpos, 2, NULL );
792         break;
793      #ifdef HAVE_LIBGDBM
794       case rt_GDBM:
795         log_debug("deleting gdbm keyblock is not yet implemented\n");
796         rc = 0;
797         break;
798      #endif
799       default: BUG();
800     }
801
802     return rc;
803 }
804
805
806 /****************
807  * Update the keyblock at KBPOS with the one in ROOT.
808  */
809 int
810 update_keyblock( KBPOS *kbpos, KBNODE root )
811 {
812     int rc;
813
814     if( !check_pos(kbpos) )
815         return G10ERR_GENERAL;
816
817     switch( kbpos->rt ) {
818       case rt_RING:
819         rc = keyring_copy( kbpos, 3, root );
820         break;
821      #ifdef HAVE_LIBGDBM
822       case rt_GDBM:
823         rc = do_gdbm_store( kbpos, root, 1 );
824         break;
825      #endif
826       default: BUG();
827     }
828
829     return rc;
830 }
831
832
833 \f
834 /****************************************************************
835  ********** Functions which operates on regular keyrings ********
836  ****************************************************************/
837
838 static int
839 cmp_seckey( PKT_secret_key *req_sk, PKT_secret_key *sk )
840 {
841     int n,i;
842
843     assert( req_sk->pubkey_algo == sk->pubkey_algo );
844
845     n = pubkey_get_nskey( req_sk->pubkey_algo );
846     for(i=0; i < n; i++ ) {
847         if( mpi_cmp( req_sk->skey[i], sk->skey[i] ) )
848             return -1;
849     }
850     return 0;
851 }
852
853 static int
854 cmp_pubkey( PKT_public_key *req_pk, PKT_public_key *pk )
855 {
856     int n, i;
857
858     assert( req_pk->pubkey_algo == pk->pubkey_algo );
859
860     n = pubkey_get_npkey( req_pk->pubkey_algo );
861     for(i=0; i < n; i++ ) {
862         if( mpi_cmp( req_pk->pkey[i], pk->pkey[i] )  )
863             return -1;
864     }
865     return 0;
866 }
867
868 /****************
869  * search one keyring, return 0 if found, -1 if not found or an errorcode.
870  */
871 static int
872 keyring_search( PACKET *req, KBPOS *kbpos, IOBUF iobuf, const char *fname )
873 {
874     int rc;
875     PACKET pkt;
876     int save_mode;
877     ulong offset;
878     int pkttype = req->pkttype;
879     PKT_public_key *req_pk = req->pkt.public_key;
880     PKT_secret_key *req_sk = req->pkt.secret_key;
881
882     init_packet(&pkt);
883     save_mode = set_packet_list_mode(0);
884     kbpos->rt = rt_RING;
885
886   #if __MINGW32__
887     assert(!iobuf);
888     iobuf = iobuf_open( fname );
889     if( !iobuf ) {
890         log_error("%s: can't open keyring file\n", fname);
891         rc = G10ERR_KEYRING_OPEN;
892         goto leave;
893     }
894   #else
895     if( iobuf_seek( iobuf, 0 ) ) {
896         log_error("can't rewind keyring file\n");
897         rc = G10ERR_KEYRING_OPEN;
898         goto leave;
899     }
900   #endif
901
902     while( !(rc=search_packet(iobuf, &pkt, pkttype, &offset)) ) {
903         if( pkt.pkttype == PKT_SECRET_KEY ) {
904             PKT_secret_key *sk = pkt.pkt.secret_key;
905
906             if(   req_sk->timestamp == sk->timestamp
907                && req_sk->pubkey_algo == sk->pubkey_algo
908                && !cmp_seckey( req_sk, sk) )
909                 break; /* found */
910         }
911         else if( pkt.pkttype == PKT_PUBLIC_KEY ) {
912             PKT_public_key *pk = pkt.pkt.public_key;
913
914             if(   req_pk->timestamp == pk->timestamp
915                && req_pk->pubkey_algo == pk->pubkey_algo
916                && !cmp_pubkey( req_pk, pk ) )
917                 break; /* found */
918         }
919         else
920             BUG();
921         free_packet(&pkt);
922     }
923     if( !rc )
924         kbpos->offset = offset;
925
926   leave:
927     free_packet(&pkt);
928     set_packet_list_mode(save_mode);
929   #if __MINGW32__
930     iobuf_close(iobuf);
931   #endif
932     return rc;
933 }
934
935
936 static int
937 keyring_read( KBPOS *kbpos, KBNODE *ret_root )
938 {
939     PACKET *pkt;
940     int rc;
941     RESTBL *rentry;
942     KBNODE root = NULL;
943     IOBUF a;
944     int in_cert = 0;
945
946     if( !(rentry=check_pos(kbpos)) )
947         return G10ERR_GENERAL;
948
949     a = iobuf_fopen( rentry->fname, "rb" );
950     if( !a ) {
951         log_error("can't open '%s'\n", rentry->fname );
952         return G10ERR_OPEN_FILE;
953     }
954
955     if( iobuf_seek( a, kbpos->offset ) ) {
956         log_error("can't seek to %lu\n", kbpos->offset);
957         iobuf_close(a);
958         return G10ERR_KEYRING_OPEN;
959     }
960
961     pkt = m_alloc( sizeof *pkt );
962     init_packet(pkt);
963     kbpos->count=0;
964     while( (rc=parse_packet(a, pkt)) != -1 ) {
965         if( rc ) {  /* ignore errors */
966             if( rc != G10ERR_UNKNOWN_PACKET ) {
967                 log_error("read_keyblock: read error: %s\n", g10_errstr(rc) );
968                 rc = G10ERR_INV_KEYRING;
969                 goto ready;
970             }
971             kbpos->count++;
972             free_packet( pkt );
973             init_packet( pkt );
974             continue;
975         }
976         /* make a linked list of all packets */
977         switch( pkt->pkttype ) {
978           case PKT_PUBLIC_KEY:
979           case PKT_SECRET_KEY:
980             if( in_cert )
981                 goto ready;
982             in_cert = 1;
983           default:
984             kbpos->count++;
985             if( !root )
986                 root = new_kbnode( pkt );
987             else
988                 add_kbnode( root, new_kbnode( pkt ) );
989             pkt = m_alloc( sizeof *pkt );
990             init_packet(pkt);
991             break;
992         }
993     }
994   ready:
995     if( rc == -1 && root )
996         rc = 0;
997
998     if( rc )
999         release_kbnode( root );
1000     else
1001         *ret_root = root;
1002     free_packet( pkt );
1003     m_free( pkt );
1004     iobuf_close(a);
1005     return rc;
1006 }
1007
1008
1009 static int
1010 keyring_enum( KBPOS *kbpos, KBNODE *ret_root, int skipsigs )
1011 {
1012     PACKET *pkt;
1013     int rc;
1014     RESTBL *rentry;
1015     KBNODE root = NULL;
1016
1017     if( !(rentry=check_pos(kbpos)) )
1018         return G10ERR_GENERAL;
1019
1020     if( kbpos->pkt ) {
1021         root = new_kbnode( kbpos->pkt );
1022         kbpos->pkt = NULL;
1023     }
1024
1025     pkt = m_alloc( sizeof *pkt );
1026     init_packet(pkt);
1027     while( (rc=parse_packet(kbpos->fp, pkt)) != -1 ) {
1028         if( rc ) {  /* ignore errors */
1029             if( rc != G10ERR_UNKNOWN_PACKET ) {
1030                 log_error("read_keyblock: read error: %s\n", g10_errstr(rc) );
1031                 rc = G10ERR_INV_KEYRING;
1032                 goto ready;
1033             }
1034             free_packet( pkt );
1035             init_packet( pkt );
1036             continue;
1037         }
1038         /* make a linked list of all packets */
1039         switch( pkt->pkttype ) {
1040           case PKT_PUBLIC_KEY:
1041           case PKT_SECRET_KEY:
1042             if( root ) { /* store this packet */
1043                 kbpos->pkt = pkt;
1044                 pkt = NULL;
1045                 goto ready;
1046             }
1047             root = new_kbnode( pkt );
1048             pkt = m_alloc( sizeof *pkt );
1049             init_packet(pkt);
1050             break;
1051
1052           default:
1053             /* skip pakets at the beginning of a keyring, until we find
1054              * a start packet; issue a warning if it is not a comment */
1055             if( !root && pkt->pkttype != PKT_COMMENT
1056                       && pkt->pkttype != PKT_OLD_COMMENT ) {
1057                 break;
1058             }
1059             if( !root || (skipsigs && ( pkt->pkttype == PKT_SIGNATURE
1060                                       ||pkt->pkttype == PKT_COMMENT
1061                                       ||pkt->pkttype == PKT_OLD_COMMENT )) ) {
1062                 init_packet(pkt);
1063                 break;
1064             }
1065             add_kbnode( root, new_kbnode( pkt ) );
1066             pkt = m_alloc( sizeof *pkt );
1067             init_packet(pkt);
1068             break;
1069         }
1070     }
1071   ready:
1072     if( rc == -1 && root )
1073         rc = 0;
1074
1075     if( rc )
1076         release_kbnode( root );
1077     else
1078         *ret_root = root;
1079     free_packet( pkt );
1080     m_free( pkt );
1081
1082     return rc;
1083 }
1084
1085
1086 /****************
1087  * Perform insert/delete/update operation.
1088  * mode 1 = insert
1089  *      2 = delete
1090  *      3 = update
1091  */
1092 static int
1093 keyring_copy( KBPOS *kbpos, int mode, KBNODE root )
1094 {
1095     RESTBL *rentry;
1096     IOBUF fp, newfp;
1097     int rc=0;
1098     char *bakfname = NULL;
1099     char *tmpfname = NULL;
1100
1101     if( !(rentry = check_pos( kbpos )) )
1102         return G10ERR_GENERAL;
1103     if( kbpos->fp )
1104         BUG(); /* not allowed with such a handle */
1105
1106     /* open the source file */
1107     fp = iobuf_fopen( rentry->fname, "rb" );
1108     if( mode == 1 && !fp && errno == ENOENT ) { /* no file yet */
1109         KBNODE kbctx, node;
1110
1111         /* insert: create a new file */
1112         newfp = iobuf_create( rentry->fname );
1113         if( !newfp ) {
1114             log_error(_("%s: can't create: %s\n"), rentry->fname, strerror(errno));
1115             return G10ERR_OPEN_FILE;
1116         }
1117         else
1118             log_info(_("%s: keyring created\n"), rentry->fname );
1119
1120         kbctx=NULL;
1121         while( (node = walk_kbnode( root, &kbctx, 0 )) ) {
1122             if( (rc = build_packet( newfp, node->pkt )) ) {
1123                 log_error("build_packet(%d) failed: %s\n",
1124                             node->pkt->pkttype, g10_errstr(rc) );
1125                 iobuf_cancel(newfp);
1126                 return G10ERR_WRITE_FILE;
1127             }
1128         }
1129         if( iobuf_close(newfp) ) {
1130             log_error("%s: close failed: %s\n", rentry->fname, strerror(errno));
1131             return G10ERR_CLOSE_FILE;
1132         }
1133         if( chmod( rentry->fname, S_IRUSR | S_IWUSR ) ) {
1134             log_error("%s: chmod failed: %s\n",
1135                                     rentry->fname, strerror(errno) );
1136             return G10ERR_WRITE_FILE;
1137         }
1138         return 0;
1139     }
1140     if( !fp ) {
1141         log_error("%s: can't open: %s\n", rentry->fname, strerror(errno) );
1142         rc = G10ERR_OPEN_FILE;
1143         goto leave;
1144     }
1145
1146     /* create the new file */
1147   #ifdef __MINGW32__
1148     /* Here is another Windoze bug?:
1149      * you cant rename("pubring.gpg.tmp", "pubring.gpg");
1150      * but      rename("pubring.gpg.tmp", "pubring.aaa");
1151      * works.  So we replace .gpg by .bak or .tmp
1152      */
1153     if( strlen(rentry->fname) > 4
1154         && !strcmp(rentry->fname+strlen(rentry->fname)-4, ".gpg") ) {
1155         bakfname = m_alloc( strlen( rentry->fname ) + 1 );
1156         strcpy(bakfname,rentry->fname);
1157         strcpy(bakfname+strlen(rentry->fname)-4, ".bak");
1158         tmpfname = m_alloc( strlen( rentry->fname ) + 1 );
1159         strcpy(tmpfname,rentry->fname);
1160         strcpy(tmpfname+strlen(rentry->fname)-4, ".tmp");
1161     }
1162     else { /* file does not end with gpg; hmmm */
1163         bakfname = m_alloc( strlen( rentry->fname ) + 5 );
1164         strcpy(stpcpy(bakfname,rentry->fname),".bak");
1165         tmpfname = m_alloc( strlen( rentry->fname ) + 5 );
1166         strcpy(stpcpy(tmpfname,rentry->fname),".tmp");
1167     }
1168   #else
1169     bakfname = m_alloc( strlen( rentry->fname ) + 2 );
1170     strcpy(stpcpy(bakfname,rentry->fname),"~");
1171     tmpfname = m_alloc( strlen( rentry->fname ) + 5 );
1172     strcpy(stpcpy(tmpfname,rentry->fname),".tmp");
1173   #endif
1174     newfp = iobuf_create( tmpfname );
1175     if( !newfp ) {
1176         log_error("%s: can't create: %s\n", tmpfname, strerror(errno) );
1177         iobuf_close(fp);
1178         rc = G10ERR_OPEN_FILE;
1179         goto leave;
1180     }
1181
1182     if( mode == 1 ) { /* insert */
1183         /* copy everything to the new file */
1184         rc = copy_all_packets( fp, newfp );
1185         if( rc != -1 ) {
1186             log_error("%s: copy to %s failed: %s\n",
1187                       rentry->fname, tmpfname, g10_errstr(rc) );
1188             iobuf_close(fp);
1189             iobuf_cancel(newfp);
1190             goto leave;
1191         }
1192         rc = 0;
1193     }
1194
1195     if( mode == 2 || mode == 3 ) { /* delete or update */
1196         /* copy first part to the new file */
1197         rc = copy_some_packets( fp, newfp, kbpos->offset );
1198         if( rc ) { /* should never get EOF here */
1199             log_error("%s: copy to %s failed: %s\n",
1200                       rentry->fname, tmpfname, g10_errstr(rc) );
1201             iobuf_close(fp);
1202             iobuf_cancel(newfp);
1203             goto leave;
1204         }
1205         /* skip this keyblock */
1206         assert( kbpos->count );
1207         rc = skip_some_packets( fp, kbpos->count );
1208         if( rc ) {
1209             log_error("%s: skipping %u packets failed: %s\n",
1210                             rentry->fname, kbpos->count, g10_errstr(rc));
1211             iobuf_close(fp);
1212             iobuf_cancel(newfp);
1213             goto leave;
1214         }
1215     }
1216
1217     if( mode == 1 || mode == 3 ) { /* insert or update */
1218         KBNODE kbctx, node;
1219
1220         /* append the new data */
1221         kbctx=NULL;
1222         while( (node = walk_kbnode( root, &kbctx, 0 )) ) {
1223             if( (rc = build_packet( newfp, node->pkt )) ) {
1224                 log_error("build_packet(%d) failed: %s\n",
1225                             node->pkt->pkttype, g10_errstr(rc) );
1226                 iobuf_close(fp);
1227                 iobuf_cancel(newfp);
1228                 rc = G10ERR_WRITE_FILE;
1229                 goto leave;
1230             }
1231         }
1232     }
1233
1234     if( mode == 2 || mode == 3 ) { /* delete or update */
1235         /* copy the rest */
1236         rc = copy_all_packets( fp, newfp );
1237         if( rc != -1 ) {
1238             log_error("%s: copy to %s failed: %s\n",
1239                       rentry->fname, tmpfname, g10_errstr(rc) );
1240             iobuf_close(fp);
1241             iobuf_cancel(newfp);
1242             goto leave;
1243         }
1244         rc = 0;
1245     }
1246
1247     /* close both files */
1248     if( iobuf_close(fp) ) {
1249         log_error("%s: close failed: %s\n", rentry->fname, strerror(errno) );
1250         rc = G10ERR_CLOSE_FILE;
1251         goto leave;
1252     }
1253     if( iobuf_close(newfp) ) {
1254         log_error("%s: close failed: %s\n", tmpfname, strerror(errno) );
1255         rc = G10ERR_CLOSE_FILE;
1256         goto leave;
1257     }
1258     /* if the new file is a secring, restrict the permissions */
1259   #ifndef __MINGW32__
1260     if( rentry->secret ) {
1261         if( chmod( tmpfname, S_IRUSR | S_IWUSR ) ) {
1262             log_error("%s: chmod failed: %s\n",
1263                                     tmpfname, strerror(errno) );
1264             rc = G10ERR_WRITE_FILE;
1265             goto leave;
1266         }
1267     }
1268   #endif
1269
1270     /* rename and make backup file */
1271     if( !rentry->secret ) {  /* but not for secret keyrings */
1272       #ifdef __MINGW32__
1273         remove( bakfname );
1274       #endif
1275         if( rename( rentry->fname, bakfname ) ) {
1276             log_error("%s: rename to %s failed: %s\n",
1277                                     rentry->fname, bakfname, strerror(errno) );
1278             rc = G10ERR_RENAME_FILE;
1279             goto leave;
1280         }
1281     }
1282   #ifdef __MINGW32__
1283     remove( rentry->fname );
1284   #endif
1285     if( rename( tmpfname, rentry->fname ) ) {
1286         log_error("%s: rename to %s failed: %s\n",
1287                             tmpfname, rentry->fname,strerror(errno) );
1288         rc = G10ERR_RENAME_FILE;
1289         if( rentry->secret ) {
1290             log_info(_(
1291                 "WARNING: 2 files with confidential information exists.\n"));
1292             log_info(_("%s is the unchanged one\n"), rentry->fname );
1293             log_info(_("%s is the new one\n"), tmpfname );
1294             log_info(_("Please fix this possible security flaw\n"));
1295         }
1296         goto leave;
1297     }
1298
1299   leave:
1300     m_free(bakfname);
1301     m_free(tmpfname);
1302     return rc;
1303 }
1304
1305 \f
1306 #ifdef HAVE_LIBGDBM
1307 /****************************************************************
1308  ********** Functions which operates on GDM files ***************
1309  ****************************************************************/
1310
1311 #if MAX_FINGERPRINT_LEN > 20
1312   #error A GDBM keyring assumes that fingerprints are less than 21
1313 #endif
1314
1315 /****************
1316  * Insert the keyblock into the GDBM database
1317  */
1318
1319 static int
1320 do_gdbm_store( KBPOS *kbpos, KBNODE root, int update )
1321 {
1322     RESTBL *rentry;
1323     PKT_public_key *pk;
1324     KBNODE kbctx, node;
1325     IOBUF fp = NULL;
1326     byte fpr[20];
1327     byte contbuf[21];
1328     byte keybuf[21];
1329     size_t fprlen;
1330     datum key, content;
1331     int i, rc;
1332
1333     if( !(rentry = check_pos( kbpos )) )
1334         return G10ERR_GENERAL;
1335
1336     /* construct the fingerprint which is used as the primary key */
1337     node = find_kbnode( root, PKT_PUBLIC_KEY );
1338     if( !node )
1339         log_bug("a gdbm database can't store secret keys\n");
1340     pk = node->pkt->pkt.public_key;
1341
1342     fingerprint_from_pk( pk, fpr, &fprlen );
1343     for(i=fprlen; i < DIM(fpr); i++ )
1344         fpr[i] = 0;
1345
1346     /* build the keyblock */
1347     kbctx=NULL;
1348     fp = iobuf_temp();
1349     iobuf_put( fp, 1 ); /* data is a keyblock */
1350     while( (node = walk_kbnode( root, &kbctx, 0 )) ) {
1351         if( (rc = build_packet( fp, node->pkt )) ) {
1352             log_error("build_packet(%d) failed: %s\n",
1353                         node->pkt->pkttype, g10_errstr(rc) );
1354             rc = G10ERR_WRITE_FILE;
1355             goto leave;
1356         }
1357     }
1358     /* store data and key */
1359     *keybuf = 1;   /* key is a padded fingerprint */
1360     memcpy(keybuf+1, fpr, 20 );
1361     key.dptr  = keybuf;
1362     key.dsize = 21;
1363     content.dptr  = iobuf_get_temp_buffer( fp );
1364     content.dsize = iobuf_get_temp_length( fp );
1365     rc = gdbm_store( rentry->dbf, key, content,
1366                                   update? GDBM_REPLACE : GDBM_INSERT );
1367     if( rc ) {
1368         log_error("%s: gdbm_store failed: %s\n", rentry->fname,
1369                             rc == 1 ? "already stored"
1370                                     : gdbm_strerror(gdbm_errno) );
1371         rc = G10ERR_WRITE_FILE;
1372         goto leave;
1373     }
1374     /* now store all keyids */
1375     *contbuf = 2;  /* data is a list of fingerprints */
1376     memcpy(contbuf+1, fpr, 20 );
1377     content.dptr = contbuf;
1378     content.dsize= 21;
1379     kbctx=NULL;
1380     while( (node = walk_kbnode( root, &kbctx, 0 )) ) {
1381         if(    node->pkt->pkttype == PKT_PUBLIC_KEY
1382             || node->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
1383             u32 aki[2];
1384
1385             keyid_from_pk( node->pkt->pkt.public_key, aki );
1386             *keybuf = 2; /* key is a 8 byte keyid */
1387             u32tobuf( keybuf+1  , aki[0] );
1388             u32tobuf( keybuf+5, aki[1] );
1389             key.dptr = keybuf;
1390             key.dsize= 9;
1391             /* fixme: must be more clever when a insert failed:
1392              *        build a list of fingerprints in this case */
1393             rc = gdbm_store( rentry->dbf, key, content,
1394                                           update? GDBM_REPLACE : GDBM_INSERT );
1395             if( rc ) {
1396                 log_info("%s: gdbm_store keyid failed: %s\n", rentry->fname,
1397                                     rc == 1 ? "already stored"
1398                                             : gdbm_strerror(gdbm_errno) );
1399                 rc = 0;
1400             }
1401         }
1402     }
1403
1404   leave:
1405     iobuf_close(fp); /* don't need a cancel because it is a temp iobuf */
1406     return rc;
1407 }
1408
1409
1410
1411 /****************
1412  * search one keybox, return 0 if found, -1 if not found or an errorcode.
1413  */
1414 static int
1415 do_gdbm_locate( GDBM_FILE dbf, KBPOS *kbpos, const byte *fpr, int fprlen )
1416 {
1417     byte *keybuf = kbpos->keybuf;
1418     datum key;
1419     int i;
1420
1421     *keybuf = 1;
1422     for(i=0; i < fprlen; i++ )
1423         keybuf[i+1] = fpr[i];
1424     for(; i < 20; i++ )
1425         keybuf[i+1] = 0;
1426
1427     /* fetch the data */
1428     key.dptr  = keybuf;
1429     key.dsize = 21;
1430     if( !gdbm_exists( dbf, key ) )
1431         return -1; /* not found */
1432     return 0;
1433 }
1434
1435 /****************
1436  * locate by keyid.
1437  * FIXME: we must have a way to enumerate thru the list opf fingerprints
1438  */
1439 static int
1440 do_gdbm_locate_by_keyid( GDBM_FILE dbf, KBPOS *kbpos, u32 *keyid )
1441 {
1442     byte keybuf[9];
1443     datum key, content;
1444     int rc;
1445
1446     /* construct the fingerprint which is used as the primary key */
1447     *keybuf = 2;
1448     u32tobuf( keybuf+1, keyid[0] );
1449     u32tobuf( keybuf+5, keyid[1] );
1450
1451     /* fetch the data */
1452     key.dptr  = keybuf;
1453     key.dsize = 9;
1454     content = gdbm_fetch( dbf, key );
1455     if( !content.dptr )
1456         return -1;
1457
1458     if( content.dsize < 2 ) {
1459         log_error("gdbm_fetch did not return enough data\n" );
1460         free( content.dptr ); /* can't use m_free() here */
1461         return G10ERR_INV_KEYRING;
1462     }
1463     if( *content.dptr != 2 ) {
1464         log_error("gdbm_fetch returned unexpected type %d\n",
1465                     *(byte*)content.dptr );
1466         free( content.dptr ); /* can't use m_free() here */
1467         return G10ERR_INV_KEYRING;
1468     }
1469     if( content.dsize < 21 ) {
1470         log_error("gdbm_fetch did not return a complete fingerprint\n" );
1471         free( content.dptr ); /* can't use m_free() here */
1472         return G10ERR_INV_KEYRING;
1473     }
1474     if( content.dsize > 21 )
1475         log_info("gdbm_fetch: WARNING: more than one fingerprint\n" );
1476
1477     rc = do_gdbm_locate( dbf, kbpos, content.dptr+1, 20 );
1478     free( content.dptr ); /* can't use m_free() here */
1479     return rc;
1480 }
1481
1482
1483
1484 static int
1485 do_gdbm_read( KBPOS *kbpos, KBNODE *ret_root )
1486 {
1487     PACKET *pkt;
1488     int rc;
1489     RESTBL *rentry;
1490     KBNODE root = NULL;
1491     IOBUF a;
1492     datum key, content;
1493
1494     if( !(rentry=check_pos(kbpos)) )
1495         return G10ERR_GENERAL;
1496
1497     key.dptr  = kbpos->keybuf;
1498     key.dsize = 21;
1499     content = gdbm_fetch( rentry->dbf, key );
1500     if( !content.dptr ) {
1501         log_error("gdbm_fetch failed: %s\n", gdbm_strerror(gdbm_errno) );
1502         return G10ERR_INV_KEYRING;
1503     }
1504     if( content.dsize < 2 ) {
1505         log_error("gdbm_fetch did not return enough data\n" );
1506         free( content.dptr ); /* can't use m_free() here */
1507         return G10ERR_INV_KEYRING;
1508     }
1509     if( *content.dptr != 1 ) {
1510         log_error("gdbm_fetch returned unexpected type %d\n",
1511                     *(byte*)content.dptr );
1512         free( content.dptr ); /* can't use m_free() here */
1513         return G10ERR_INV_KEYRING;
1514     }
1515
1516     a = iobuf_temp_with_content( content.dptr+1, content.dsize-1 );
1517     free( content.dptr ); /* can't use m_free() here */
1518
1519     pkt = m_alloc( sizeof *pkt );
1520     init_packet(pkt);
1521     kbpos->count=0;
1522     while( (rc=parse_packet(a, pkt)) != -1 ) {
1523         if( rc ) {  /* ignore errors */
1524             if( rc != G10ERR_UNKNOWN_PACKET ) {
1525                 log_error("read_keyblock: read error: %s\n", g10_errstr(rc) );
1526                 rc = G10ERR_INV_KEYRING;
1527                 break;
1528             }
1529             kbpos->count++;
1530             free_packet( pkt );
1531             init_packet( pkt );
1532             continue;
1533         }
1534         /* make a linked list of all packets */
1535         kbpos->count++;
1536         if( !root )
1537             root = new_kbnode( pkt );
1538         else
1539             add_kbnode( root, new_kbnode( pkt ) );
1540         pkt = m_alloc( sizeof *pkt );
1541         init_packet(pkt);
1542     }
1543     if( rc == -1 && root )
1544         rc = 0;
1545     if( rc )
1546         release_kbnode( root );
1547     else
1548         *ret_root = root;
1549     free_packet( pkt );
1550     m_free( pkt );
1551     iobuf_close(a);
1552     return rc;
1553 }
1554
1555
1556 /****************
1557  * Enum over keyblok data
1558  */
1559 static int
1560 do_gdbm_enum( KBPOS *kbpos, KBNODE *ret_root )
1561 {
1562     RESTBL *rentry;
1563     datum key, helpkey;
1564
1565     if( !(rentry=check_pos(kbpos)) )
1566         return G10ERR_GENERAL;
1567
1568     if( !kbpos->offset ) {
1569         kbpos->offset = 1;
1570         key = gdbm_firstkey( rentry->dbf );
1571     }
1572     else {
1573         helpkey.dptr = kbpos->keybuf;
1574         helpkey.dsize= 21;
1575         key = gdbm_nextkey( rentry->dbf, helpkey );
1576     }
1577     while( key.dptr && (!key.dsize || *key.dptr != 1) ) {
1578         helpkey = key;
1579         key = gdbm_nextkey( rentry->dbf, helpkey );
1580         free( helpkey.dptr ); /* free and not m_free() ! */
1581     }
1582     if( !key.dptr )
1583         return -1; /* eof */
1584
1585     if( key.dsize < 21 ) {
1586         free( key.dptr ); /* free and not m_free() ! */
1587         log_error("do_gdm_enum: key is too short\n" );
1588         return G10ERR_INV_KEYRING;
1589     }
1590     memcpy( kbpos->keybuf, key.dptr, 21 );
1591     free( key.dptr ); /* free and not m_free() ! */
1592     return do_gdbm_read( kbpos, ret_root );
1593 }
1594
1595 #endif /*HAVE_LIBGDBM*/