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