See ChangeLog ;-). Key validation should now be faster
[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  ********** Implemenation of a user ID database    **************
836  ****************************************************************/
837 #if 0
838 /****************
839  * Layout of the user ID db
840  *
841  * This user ID DB provides fast lookup of user ID, but the user ids are
842  * not in any specific order.
843  *
844  * A string "GnuPG user db", a \n.
845  * user ids of one key, delimited by \t,
846  * a # or ^ followed by a 20 byte fingerprint, followed by an \n 
847  * The literal characters =, \n, \t, #, ^ must be replaced by a equal sign
848  * and their hex value.
849  *
850  * (We use Boyer/Moore pattern matching)
851  */
852
853 /****************
854  * This compiles pattern to the distance table, the table will be allocate
855  * here and must be freed by using free().
856  * Returns: Ptr to new allocated Table
857  *          Caller must free the table.
858  */
859
860 static size_t *
861 compile_bm_table( const byte *pattern, size_t len )
862 {
863     ushort *dist;
864     int i;
865
866     dist = m_alloc_clear( 256 * sizeof *dist );
867     for(i=0; i < 256; i++ )
868         dist[i] = len;
869     for(i=0; i < len-1; i++ )
870         dTbl[p[i]] = len-i-1;
871     return dist;
872 }
873
874
875
876
877 /****************
878  * Search BUF of BUFLEN for pattern P of length PATLEN.
879  * dist is the Boyer/Moore distance table of 256 Elements,
880  * case insensitive search is done if IGNCASE is true (In this case
881  * the distance table has to compiled from uppercase chacaters and
882  * PAT must also be uppercase.
883  * Returns: Prt to maching string in BUF, or NULL if not found.
884  */
885
886 static const *
887 do_bm_search( const byte *buf, size_t buflen,
888               const byte *pat, size_t patlen, size_t *dist, int igncase )
889 {
890     int i, j, k;
891
892     if( igncase ) {
893         int c, c1;
894
895         for( i = --patlen; i < buflen; i += dist[c1] )
896             for( j=patlen, k=i, c1=c=toupper(buf[k]); c == pat[j];
897                                           j--, k--, c=toupper(buf[k]) ) {
898                 if( !j )
899                     return buf+k;
900             }
901     }
902     else {
903         for( i = --patlen; i < buflen; i += dist[buf[i]] )
904             for( j=patlen, k=i; buf[k] == pat[j]; j--, k-- ) {
905                 if( !j )
906                     return buf+k;
907             }
908     }
909     return NULL;
910 }
911
912
913 typedef struct {
914     size_t dist[256];
915 } *SCAN_USER_HANDLE;
916
917 static SCAN_USER_HANDLE
918 scan_user_file_open( const byte *name )
919 {
920     SCAN_USER_HANDLE hd;
921     size_t *dist;
922     int i;
923
924     hd = m_alloc_clear( sizeof *hd );
925     dist = hd->dist;
926     /* compile the distance table */
927     for(i=0; i < 256; i++ )
928         dist[i] = len;
929     for(i=0; i < len-1; i++ )
930         dTbl[p[i]] = len-i-1;
931     /* setup other things */
932
933     return hd;
934 }
935
936 static int
937 scan_user_file_close( SCAN_USER_HANDLE hd )
938 {
939     m_free( hd );
940 }
941
942 static int
943 scan_user_file_read( SCAN_USER_HANDLE hd, byte *fpr )
944 {
945     char record[1000];
946
947     /* read a record */
948
949
950 }
951 #endif
952
953
954 \f
955 /****************************************************************
956  ********** Functions which operates on regular keyrings ********
957  ****************************************************************/
958
959 static int
960 cmp_seckey( PKT_secret_key *req_sk, PKT_secret_key *sk )
961 {
962     int n,i;
963
964     assert( req_sk->pubkey_algo == sk->pubkey_algo );
965
966     n = pubkey_get_nskey( req_sk->pubkey_algo );
967     for(i=0; i < n; i++ ) {
968         if( mpi_cmp( req_sk->skey[i], sk->skey[i] ) )
969             return -1;
970     }
971     return 0;
972 }
973
974 static int
975 cmp_pubkey( PKT_public_key *req_pk, PKT_public_key *pk )
976 {
977     int n, i;
978
979     assert( req_pk->pubkey_algo == pk->pubkey_algo );
980
981     n = pubkey_get_npkey( req_pk->pubkey_algo );
982     for(i=0; i < n; i++ ) {
983         if( mpi_cmp( req_pk->pkey[i], pk->pkey[i] )  )
984             return -1;
985     }
986     return 0;
987 }
988
989 /****************
990  * search one keyring, return 0 if found, -1 if not found or an errorcode.
991  */
992 static int
993 keyring_search( PACKET *req, KBPOS *kbpos, IOBUF iobuf, const char *fname )
994 {
995     int rc;
996     PACKET pkt;
997     int save_mode;
998     ulong offset;
999     int pkttype = req->pkttype;
1000     PKT_public_key *req_pk = req->pkt.public_key;
1001     PKT_secret_key *req_sk = req->pkt.secret_key;
1002
1003     init_packet(&pkt);
1004     save_mode = set_packet_list_mode(0);
1005     kbpos->rt = rt_RING;
1006
1007   #if __MINGW32__
1008     assert(!iobuf);
1009     iobuf = iobuf_open( fname );
1010     if( !iobuf ) {
1011         log_error("%s: can't open keyring file\n", fname);
1012         rc = G10ERR_KEYRING_OPEN;
1013         goto leave;
1014     }
1015   #else
1016     if( iobuf_seek( iobuf, 0 ) ) {
1017         log_error("can't rewind keyring file\n");
1018         rc = G10ERR_KEYRING_OPEN;
1019         goto leave;
1020     }
1021   #endif
1022
1023     while( !(rc=search_packet(iobuf, &pkt, pkttype, &offset)) ) {
1024         if( pkt.pkttype == PKT_SECRET_KEY ) {
1025             PKT_secret_key *sk = pkt.pkt.secret_key;
1026
1027             if(   req_sk->timestamp == sk->timestamp
1028                && req_sk->pubkey_algo == sk->pubkey_algo
1029                && !cmp_seckey( req_sk, sk) )
1030                 break; /* found */
1031         }
1032         else if( pkt.pkttype == PKT_PUBLIC_KEY ) {
1033             PKT_public_key *pk = pkt.pkt.public_key;
1034
1035             if(   req_pk->timestamp == pk->timestamp
1036                && req_pk->pubkey_algo == pk->pubkey_algo
1037                && !cmp_pubkey( req_pk, pk ) )
1038                 break; /* found */
1039         }
1040         else
1041             BUG();
1042         free_packet(&pkt);
1043     }
1044     if( !rc )
1045         kbpos->offset = offset;
1046
1047   leave:
1048     free_packet(&pkt);
1049     set_packet_list_mode(save_mode);
1050   #if __MINGW32__
1051     iobuf_close(iobuf);
1052   #endif
1053     return rc;
1054 }
1055
1056
1057 static int
1058 keyring_read( KBPOS *kbpos, KBNODE *ret_root )
1059 {
1060     PACKET *pkt;
1061     int rc;
1062     RESTBL *rentry;
1063     KBNODE root = NULL;
1064     IOBUF a;
1065     int in_cert = 0;
1066
1067     if( !(rentry=check_pos(kbpos)) )
1068         return G10ERR_GENERAL;
1069
1070     a = iobuf_fopen( rentry->fname, "rb" );
1071     if( !a ) {
1072         log_error("can't open '%s'\n", rentry->fname );
1073         return G10ERR_OPEN_FILE;
1074     }
1075
1076     if( iobuf_seek( a, kbpos->offset ) ) {
1077         log_error("can't seek to %lu\n", kbpos->offset);
1078         iobuf_close(a);
1079         return G10ERR_KEYRING_OPEN;
1080     }
1081
1082     pkt = m_alloc( sizeof *pkt );
1083     init_packet(pkt);
1084     kbpos->count=0;
1085     while( (rc=parse_packet(a, pkt)) != -1 ) {
1086         if( rc ) {  /* ignore errors */
1087             if( rc != G10ERR_UNKNOWN_PACKET ) {
1088                 log_error("read_keyblock: read error: %s\n", g10_errstr(rc) );
1089                 rc = G10ERR_INV_KEYRING;
1090                 goto ready;
1091             }
1092             kbpos->count++;
1093             free_packet( pkt );
1094             init_packet( pkt );
1095             continue;
1096         }
1097         /* make a linked list of all packets */
1098         switch( pkt->pkttype ) {
1099           case PKT_PUBLIC_KEY:
1100           case PKT_SECRET_KEY:
1101             if( in_cert )
1102                 goto ready;
1103             in_cert = 1;
1104           default:
1105             kbpos->count++;
1106             if( !root )
1107                 root = new_kbnode( pkt );
1108             else
1109                 add_kbnode( root, new_kbnode( pkt ) );
1110             pkt = m_alloc( sizeof *pkt );
1111             init_packet(pkt);
1112             break;
1113         }
1114     }
1115   ready:
1116     if( rc == -1 && root )
1117         rc = 0;
1118
1119     if( rc )
1120         release_kbnode( root );
1121     else
1122         *ret_root = root;
1123     free_packet( pkt );
1124     m_free( pkt );
1125     iobuf_close(a);
1126     return rc;
1127 }
1128
1129
1130 static int
1131 keyring_enum( KBPOS *kbpos, KBNODE *ret_root, int skipsigs )
1132 {
1133     PACKET *pkt;
1134     int rc;
1135     RESTBL *rentry;
1136     KBNODE root = NULL;
1137
1138     if( !(rentry=check_pos(kbpos)) )
1139         return G10ERR_GENERAL;
1140
1141     if( kbpos->pkt ) {
1142         root = new_kbnode( kbpos->pkt );
1143         kbpos->pkt = NULL;
1144     }
1145
1146     pkt = m_alloc( sizeof *pkt );
1147     init_packet(pkt);
1148     while( (rc=parse_packet(kbpos->fp, pkt)) != -1 ) {
1149         if( rc ) {  /* ignore errors */
1150             if( rc != G10ERR_UNKNOWN_PACKET ) {
1151                 log_error("read_keyblock: read error: %s\n", g10_errstr(rc) );
1152                 rc = G10ERR_INV_KEYRING;
1153                 goto ready;
1154             }
1155             free_packet( pkt );
1156             init_packet( pkt );
1157             continue;
1158         }
1159         /* make a linked list of all packets */
1160         switch( pkt->pkttype ) {
1161           case PKT_PUBLIC_KEY:
1162           case PKT_SECRET_KEY:
1163             if( root ) { /* store this packet */
1164                 kbpos->pkt = pkt;
1165                 pkt = NULL;
1166                 goto ready;
1167             }
1168             root = new_kbnode( pkt );
1169             pkt = m_alloc( sizeof *pkt );
1170             init_packet(pkt);
1171             break;
1172
1173           default:
1174             /* skip pakets at the beginning of a keyring, until we find
1175              * a start packet; issue a warning if it is not a comment */
1176             if( !root && pkt->pkttype != PKT_COMMENT
1177                       && pkt->pkttype != PKT_OLD_COMMENT ) {
1178                 break;
1179             }
1180             if( !root || (skipsigs && ( pkt->pkttype == PKT_SIGNATURE
1181                                       ||pkt->pkttype == PKT_COMMENT
1182                                       ||pkt->pkttype == PKT_OLD_COMMENT )) ) {
1183                 init_packet(pkt);
1184                 break;
1185             }
1186             add_kbnode( root, new_kbnode( pkt ) );
1187             pkt = m_alloc( sizeof *pkt );
1188             init_packet(pkt);
1189             break;
1190         }
1191     }
1192   ready:
1193     if( rc == -1 && root )
1194         rc = 0;
1195
1196     if( rc )
1197         release_kbnode( root );
1198     else
1199         *ret_root = root;
1200     free_packet( pkt );
1201     m_free( pkt );
1202
1203     return rc;
1204 }
1205
1206
1207 /****************
1208  * Perform insert/delete/update operation.
1209  * mode 1 = insert
1210  *      2 = delete
1211  *      3 = update
1212  */
1213 static int
1214 keyring_copy( KBPOS *kbpos, int mode, KBNODE root )
1215 {
1216     RESTBL *rentry;
1217     IOBUF fp, newfp;
1218     int rc=0;
1219     char *bakfname = NULL;
1220     char *tmpfname = NULL;
1221
1222     if( !(rentry = check_pos( kbpos )) )
1223         return G10ERR_GENERAL;
1224     if( kbpos->fp )
1225         BUG(); /* not allowed with such a handle */
1226
1227     /* open the source file */
1228     fp = iobuf_fopen( rentry->fname, "rb" );
1229     if( mode == 1 && !fp && errno == ENOENT ) { /* no file yet */
1230         KBNODE kbctx, node;
1231
1232         /* insert: create a new file */
1233         newfp = iobuf_create( rentry->fname );
1234         if( !newfp ) {
1235             log_error(_("%s: can't create: %s\n"), rentry->fname, strerror(errno));
1236             return G10ERR_OPEN_FILE;
1237         }
1238         else
1239             log_info(_("%s: keyring created\n"), rentry->fname );
1240
1241         kbctx=NULL;
1242         while( (node = walk_kbnode( root, &kbctx, 0 )) ) {
1243             if( (rc = build_packet( newfp, node->pkt )) ) {
1244                 log_error("build_packet(%d) failed: %s\n",
1245                             node->pkt->pkttype, g10_errstr(rc) );
1246                 iobuf_cancel(newfp);
1247                 return G10ERR_WRITE_FILE;
1248             }
1249         }
1250         if( iobuf_close(newfp) ) {
1251             log_error("%s: close failed: %s\n", rentry->fname, strerror(errno));
1252             return G10ERR_CLOSE_FILE;
1253         }
1254         if( chmod( rentry->fname, S_IRUSR | S_IWUSR ) ) {
1255             log_error("%s: chmod failed: %s\n",
1256                                     rentry->fname, strerror(errno) );
1257             return G10ERR_WRITE_FILE;
1258         }
1259         return 0;
1260     }
1261     if( !fp ) {
1262         log_error("%s: can't open: %s\n", rentry->fname, strerror(errno) );
1263         rc = G10ERR_OPEN_FILE;
1264         goto leave;
1265     }
1266
1267     /* create the new file */
1268   #ifdef __MINGW32__
1269     /* Here is another Windoze bug?:
1270      * you cant rename("pubring.gpg.tmp", "pubring.gpg");
1271      * but      rename("pubring.gpg.tmp", "pubring.aaa");
1272      * works.  So we replace .gpg by .bak or .tmp
1273      */
1274     if( strlen(rentry->fname) > 4
1275         && !strcmp(rentry->fname+strlen(rentry->fname)-4, ".gpg") ) {
1276         bakfname = m_alloc( strlen( rentry->fname ) + 1 );
1277         strcpy(bakfname,rentry->fname);
1278         strcpy(bakfname+strlen(rentry->fname)-4, ".bak");
1279         tmpfname = m_alloc( strlen( rentry->fname ) + 1 );
1280         strcpy(tmpfname,rentry->fname);
1281         strcpy(tmpfname+strlen(rentry->fname)-4, ".tmp");
1282     }
1283     else { /* file does not end with gpg; hmmm */
1284         bakfname = m_alloc( strlen( rentry->fname ) + 5 );
1285         strcpy(stpcpy(bakfname,rentry->fname),".bak");
1286         tmpfname = m_alloc( strlen( rentry->fname ) + 5 );
1287         strcpy(stpcpy(tmpfname,rentry->fname),".tmp");
1288     }
1289   #else
1290     bakfname = m_alloc( strlen( rentry->fname ) + 2 );
1291     strcpy(stpcpy(bakfname,rentry->fname),"~");
1292     tmpfname = m_alloc( strlen( rentry->fname ) + 5 );
1293     strcpy(stpcpy(tmpfname,rentry->fname),".tmp");
1294   #endif
1295     newfp = iobuf_create( tmpfname );
1296     if( !newfp ) {
1297         log_error("%s: can't create: %s\n", tmpfname, strerror(errno) );
1298         iobuf_close(fp);
1299         rc = G10ERR_OPEN_FILE;
1300         goto leave;
1301     }
1302
1303     if( mode == 1 ) { /* insert */
1304         /* copy everything to the new file */
1305         rc = copy_all_packets( fp, newfp );
1306         if( rc != -1 ) {
1307             log_error("%s: copy to %s failed: %s\n",
1308                       rentry->fname, tmpfname, g10_errstr(rc) );
1309             iobuf_close(fp);
1310             iobuf_cancel(newfp);
1311             goto leave;
1312         }
1313         rc = 0;
1314     }
1315
1316     if( mode == 2 || mode == 3 ) { /* delete or update */
1317         /* copy first part to the new file */
1318         rc = copy_some_packets( fp, newfp, kbpos->offset );
1319         if( rc ) { /* should never get EOF here */
1320             log_error("%s: copy to %s failed: %s\n",
1321                       rentry->fname, tmpfname, g10_errstr(rc) );
1322             iobuf_close(fp);
1323             iobuf_cancel(newfp);
1324             goto leave;
1325         }
1326         /* skip this keyblock */
1327         assert( kbpos->count );
1328         rc = skip_some_packets( fp, kbpos->count );
1329         if( rc ) {
1330             log_error("%s: skipping %u packets failed: %s\n",
1331                             rentry->fname, kbpos->count, g10_errstr(rc));
1332             iobuf_close(fp);
1333             iobuf_cancel(newfp);
1334             goto leave;
1335         }
1336     }
1337
1338     if( mode == 1 || mode == 3 ) { /* insert or update */
1339         KBNODE kbctx, node;
1340
1341         /* append the new data */
1342         kbctx=NULL;
1343         while( (node = walk_kbnode( root, &kbctx, 0 )) ) {
1344             if( (rc = build_packet( newfp, node->pkt )) ) {
1345                 log_error("build_packet(%d) failed: %s\n",
1346                             node->pkt->pkttype, g10_errstr(rc) );
1347                 iobuf_close(fp);
1348                 iobuf_cancel(newfp);
1349                 rc = G10ERR_WRITE_FILE;
1350                 goto leave;
1351             }
1352         }
1353     }
1354
1355     if( mode == 2 || mode == 3 ) { /* delete or update */
1356         /* copy the rest */
1357         rc = copy_all_packets( fp, newfp );
1358         if( rc != -1 ) {
1359             log_error("%s: copy to %s failed: %s\n",
1360                       rentry->fname, tmpfname, g10_errstr(rc) );
1361             iobuf_close(fp);
1362             iobuf_cancel(newfp);
1363             goto leave;
1364         }
1365         rc = 0;
1366     }
1367
1368     /* close both files */
1369     if( iobuf_close(fp) ) {
1370         log_error("%s: close failed: %s\n", rentry->fname, strerror(errno) );
1371         rc = G10ERR_CLOSE_FILE;
1372         goto leave;
1373     }
1374     if( iobuf_close(newfp) ) {
1375         log_error("%s: close failed: %s\n", tmpfname, strerror(errno) );
1376         rc = G10ERR_CLOSE_FILE;
1377         goto leave;
1378     }
1379     /* if the new file is a secring, restrict the permissions */
1380   #ifndef __MINGW32__
1381     if( rentry->secret ) {
1382         if( chmod( tmpfname, S_IRUSR | S_IWUSR ) ) {
1383             log_error("%s: chmod failed: %s\n",
1384                                     tmpfname, strerror(errno) );
1385             rc = G10ERR_WRITE_FILE;
1386             goto leave;
1387         }
1388     }
1389   #endif
1390
1391     /* rename and make backup file */
1392     if( !rentry->secret ) {  /* but not for secret keyrings */
1393       #ifdef __MINGW32__
1394         remove( bakfname );
1395       #endif
1396         if( rename( rentry->fname, bakfname ) ) {
1397             log_error("%s: rename to %s failed: %s\n",
1398                                     rentry->fname, bakfname, strerror(errno) );
1399             rc = G10ERR_RENAME_FILE;
1400             goto leave;
1401         }
1402     }
1403   #ifdef __MINGW32__
1404     remove( rentry->fname );
1405   #endif
1406     if( rename( tmpfname, rentry->fname ) ) {
1407         log_error("%s: rename to %s failed: %s\n",
1408                             tmpfname, rentry->fname,strerror(errno) );
1409         rc = G10ERR_RENAME_FILE;
1410         if( rentry->secret ) {
1411             log_info(_(
1412                 "WARNING: 2 files with confidential information exists.\n"));
1413             log_info(_("%s is the unchanged one\n"), rentry->fname );
1414             log_info(_("%s is the new one\n"), tmpfname );
1415             log_info(_("Please fix this possible security flaw\n"));
1416         }
1417         goto leave;
1418     }
1419
1420   leave:
1421     m_free(bakfname);
1422     m_free(tmpfname);
1423     return rc;
1424 }
1425
1426 \f
1427 #ifdef HAVE_LIBGDBM
1428 /****************************************************************
1429  ********** Functions which operates on GDM files ***************
1430  ****************************************************************/
1431
1432 #if MAX_FINGERPRINT_LEN > 20
1433   #error A GDBM keyring assumes that fingerprints are less than 21
1434 #endif
1435
1436 /****************
1437  * Insert the keyblock into the GDBM database
1438  */
1439
1440 static int
1441 do_gdbm_store( KBPOS *kbpos, KBNODE root, int update )
1442 {
1443     RESTBL *rentry;
1444     PKT_public_key *pk;
1445     KBNODE kbctx, node;
1446     IOBUF fp = NULL;
1447     byte fpr[20];
1448     byte contbuf[21];
1449     byte keybuf[21];
1450     size_t fprlen;
1451     datum key, content;
1452     int i, rc;
1453
1454     if( !(rentry = check_pos( kbpos )) )
1455         return G10ERR_GENERAL;
1456
1457     /* construct the fingerprint which is used as the primary key */
1458     node = find_kbnode( root, PKT_PUBLIC_KEY );
1459     if( !node )
1460         log_bug("a gdbm database can't store secret keys\n");
1461     pk = node->pkt->pkt.public_key;
1462
1463     fingerprint_from_pk( pk, fpr, &fprlen );
1464     for(i=fprlen; i < DIM(fpr); i++ )
1465         fpr[i] = 0;
1466
1467     /* build the keyblock */
1468     kbctx=NULL;
1469     fp = iobuf_temp();
1470     iobuf_put( fp, 1 ); /* data is a keyblock */
1471     while( (node = walk_kbnode( root, &kbctx, 0 )) ) {
1472         if( (rc = build_packet( fp, node->pkt )) ) {
1473             log_error("build_packet(%d) failed: %s\n",
1474                         node->pkt->pkttype, g10_errstr(rc) );
1475             rc = G10ERR_WRITE_FILE;
1476             goto leave;
1477         }
1478     }
1479     /* store data and key */
1480     *keybuf = 1;   /* key is a padded fingerprint */
1481     memcpy(keybuf+1, fpr, 20 );
1482     key.dptr  = keybuf;
1483     key.dsize = 21;
1484     content.dptr  = iobuf_get_temp_buffer( fp );
1485     content.dsize = iobuf_get_temp_length( fp );
1486     rc = gdbm_store( rentry->dbf, key, content,
1487                                   update? GDBM_REPLACE : GDBM_INSERT );
1488     if( rc ) {
1489         log_error("%s: gdbm_store failed: %s\n", rentry->fname,
1490                             rc == 1 ? "already stored"
1491                                     : gdbm_strerror(gdbm_errno) );
1492         rc = G10ERR_WRITE_FILE;
1493         goto leave;
1494     }
1495     /* now store all keyids */
1496     *contbuf = 2;  /* data is a list of fingerprints */
1497     memcpy(contbuf+1, fpr, 20 );
1498     content.dptr = contbuf;
1499     content.dsize= 21;
1500     kbctx=NULL;
1501     while( (node = walk_kbnode( root, &kbctx, 0 )) ) {
1502         if(    node->pkt->pkttype == PKT_PUBLIC_KEY
1503             || node->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
1504             u32 aki[2];
1505
1506             keyid_from_pk( node->pkt->pkt.public_key, aki );
1507             *keybuf = 2; /* key is a 8 byte keyid */
1508             u32tobuf( keybuf+1  , aki[0] );
1509             u32tobuf( keybuf+5, aki[1] );
1510             key.dptr = keybuf;
1511             key.dsize= 9;
1512             /* fixme: must be more clever when a insert failed:
1513              *        build a list of fingerprints in this case */
1514             rc = gdbm_store( rentry->dbf, key, content,
1515                                           update? GDBM_REPLACE : GDBM_INSERT );
1516             if( rc ) {
1517                 log_info("%s: gdbm_store keyid failed: %s\n", rentry->fname,
1518                                     rc == 1 ? "already stored"
1519                                             : gdbm_strerror(gdbm_errno) );
1520                 rc = 0;
1521             }
1522         }
1523     }
1524
1525   leave:
1526     iobuf_close(fp); /* don't need a cancel because it is a temp iobuf */
1527     return rc;
1528 }
1529
1530
1531
1532 /****************
1533  * search one keybox, return 0 if found, -1 if not found or an errorcode.
1534  */
1535 static int
1536 do_gdbm_locate( GDBM_FILE dbf, KBPOS *kbpos, const byte *fpr, int fprlen )
1537 {
1538     byte *keybuf = kbpos->keybuf;
1539     datum key;
1540     int i;
1541
1542     *keybuf = 1;
1543     for(i=0; i < fprlen; i++ )
1544         keybuf[i+1] = fpr[i];
1545     for(; i < 20; i++ )
1546         keybuf[i+1] = 0;
1547
1548     /* fetch the data */
1549     key.dptr  = keybuf;
1550     key.dsize = 21;
1551     if( !gdbm_exists( dbf, key ) )
1552         return -1; /* not found */
1553     return 0;
1554 }
1555
1556 /****************
1557  * locate by keyid.
1558  * FIXME: we must have a way to enumerate thru the list opf fingerprints
1559  */
1560 static int
1561 do_gdbm_locate_by_keyid( GDBM_FILE dbf, KBPOS *kbpos, u32 *keyid )
1562 {
1563     byte keybuf[9];
1564     datum key, content;
1565     int rc;
1566
1567     /* construct the fingerprint which is used as the primary key */
1568     *keybuf = 2;
1569     u32tobuf( keybuf+1, keyid[0] );
1570     u32tobuf( keybuf+5, keyid[1] );
1571
1572     /* fetch the data */
1573     key.dptr  = keybuf;
1574     key.dsize = 9;
1575     content = gdbm_fetch( dbf, key );
1576     if( !content.dptr )
1577         return -1;
1578
1579     if( content.dsize < 2 ) {
1580         log_error("gdbm_fetch did not return enough data\n" );
1581         free( content.dptr ); /* can't use m_free() here */
1582         return G10ERR_INV_KEYRING;
1583     }
1584     if( *content.dptr != 2 ) {
1585         log_error("gdbm_fetch returned unexpected type %d\n",
1586                     *(byte*)content.dptr );
1587         free( content.dptr ); /* can't use m_free() here */
1588         return G10ERR_INV_KEYRING;
1589     }
1590     if( content.dsize < 21 ) {
1591         log_error("gdbm_fetch did not return a complete fingerprint\n" );
1592         free( content.dptr ); /* can't use m_free() here */
1593         return G10ERR_INV_KEYRING;
1594     }
1595     if( content.dsize > 21 )
1596         log_info("gdbm_fetch: WARNING: more than one fingerprint\n" );
1597
1598     rc = do_gdbm_locate( dbf, kbpos, content.dptr+1, 20 );
1599     free( content.dptr ); /* can't use m_free() here */
1600     return rc;
1601 }
1602
1603
1604
1605 static int
1606 do_gdbm_read( KBPOS *kbpos, KBNODE *ret_root )
1607 {
1608     PACKET *pkt;
1609     int rc;
1610     RESTBL *rentry;
1611     KBNODE root = NULL;
1612     IOBUF a;
1613     datum key, content;
1614
1615     if( !(rentry=check_pos(kbpos)) )
1616         return G10ERR_GENERAL;
1617
1618     key.dptr  = kbpos->keybuf;
1619     key.dsize = 21;
1620     content = gdbm_fetch( rentry->dbf, key );
1621     if( !content.dptr ) {
1622         log_error("gdbm_fetch failed: %s\n", gdbm_strerror(gdbm_errno) );
1623         return G10ERR_INV_KEYRING;
1624     }
1625     if( content.dsize < 2 ) {
1626         log_error("gdbm_fetch did not return enough data\n" );
1627         free( content.dptr ); /* can't use m_free() here */
1628         return G10ERR_INV_KEYRING;
1629     }
1630     if( *content.dptr != 1 ) {
1631         log_error("gdbm_fetch returned unexpected type %d\n",
1632                     *(byte*)content.dptr );
1633         free( content.dptr ); /* can't use m_free() here */
1634         return G10ERR_INV_KEYRING;
1635     }
1636
1637     a = iobuf_temp_with_content( content.dptr+1, content.dsize-1 );
1638     free( content.dptr ); /* can't use m_free() here */
1639
1640     pkt = m_alloc( sizeof *pkt );
1641     init_packet(pkt);
1642     kbpos->count=0;
1643     while( (rc=parse_packet(a, pkt)) != -1 ) {
1644         if( rc ) {  /* ignore errors */
1645             if( rc != G10ERR_UNKNOWN_PACKET ) {
1646                 log_error("read_keyblock: read error: %s\n", g10_errstr(rc) );
1647                 rc = G10ERR_INV_KEYRING;
1648                 break;
1649             }
1650             kbpos->count++;
1651             free_packet( pkt );
1652             init_packet( pkt );
1653             continue;
1654         }
1655         /* make a linked list of all packets */
1656         kbpos->count++;
1657         if( !root )
1658             root = new_kbnode( pkt );
1659         else
1660             add_kbnode( root, new_kbnode( pkt ) );
1661         pkt = m_alloc( sizeof *pkt );
1662         init_packet(pkt);
1663     }
1664     if( rc == -1 && root )
1665         rc = 0;
1666     if( rc )
1667         release_kbnode( root );
1668     else
1669         *ret_root = root;
1670     free_packet( pkt );
1671     m_free( pkt );
1672     iobuf_close(a);
1673     return rc;
1674 }
1675
1676
1677 /****************
1678  * Enum over keyblok data
1679  */
1680 static int
1681 do_gdbm_enum( KBPOS *kbpos, KBNODE *ret_root )
1682 {
1683     RESTBL *rentry;
1684     datum key, helpkey;
1685
1686     if( !(rentry=check_pos(kbpos)) )
1687         return G10ERR_GENERAL;
1688
1689     if( !kbpos->offset ) {
1690         kbpos->offset = 1;
1691         key = gdbm_firstkey( rentry->dbf );
1692     }
1693     else {
1694         helpkey.dptr = kbpos->keybuf;
1695         helpkey.dsize= 21;
1696         key = gdbm_nextkey( rentry->dbf, helpkey );
1697     }
1698     while( key.dptr && (!key.dsize || *key.dptr != 1) ) {
1699         helpkey = key;
1700         key = gdbm_nextkey( rentry->dbf, helpkey );
1701         free( helpkey.dptr ); /* free and not m_free() ! */
1702     }
1703     if( !key.dptr )
1704         return -1; /* eof */
1705
1706     if( key.dsize < 21 ) {
1707         free( key.dptr ); /* free and not m_free() ! */
1708         log_error("do_gdm_enum: key is too short\n" );
1709         return G10ERR_INV_KEYRING;
1710     }
1711     memcpy( kbpos->keybuf, key.dptr, 21 );
1712     free( key.dptr ); /* free and not m_free() ! */
1713     return do_gdbm_read( kbpos, ret_root );
1714 }
1715
1716 #endif /*HAVE_LIBGDBM*/