release 0.2.14
[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  * FIXME:  Keep track of all nodes, so that a change is propagated
39  *         to all nodes. (or use shallow copies and ref-counting?)
40  */
41
42
43
44 #include <config.h>
45 #include <stdio.h>
46 #include <stdlib.h>
47 #include <string.h>
48 #include <errno.h>
49 #include <sys/types.h>
50 #include <sys/stat.h>
51 #include <assert.h>
52 #include "util.h"
53 #include "packet.h"
54 #include "memory.h"
55 #include "mpi.h"
56 #include "iobuf.h"
57 #include "keydb.h"
58 #include <unistd.h> /* for truncate */
59
60
61 struct resource_table_struct {
62     int used;
63     int secret; /* this is a secret keyring */
64     char *fname;
65     IOBUF iobuf;
66 };
67 typedef struct resource_table_struct RESTBL;
68
69 #define MAX_RESOURCES 10
70 static RESTBL resource_table[MAX_RESOURCES];
71
72
73 static int search( PACKET *pkt, KBPOS *kbpos, int secret );
74
75
76 static int keyring_search( PACKET *pkt, KBPOS *kbpos, IOBUF iobuf,
77                                                 const char *fname );
78 static int keyring_search2( PUBKEY_FIND_INFO info, KBPOS *kbpos,
79                                                    const char *fname);
80 static int keyring_read( KBPOS *kbpos, KBNODE *ret_root );
81 static int keyring_enum( KBPOS *kbpos, KBNODE *ret_root, int skipsigs );
82 static int keyring_copy( KBPOS *kbpos, int mode, KBNODE root );
83
84
85
86 static RESTBL *
87 check_pos( KBPOS *kbpos )
88 {
89     if( kbpos->resno < 0 || kbpos->resno >= MAX_RESOURCES )
90         return NULL;
91     if( !resource_table[kbpos->resno].used )
92         return NULL;
93     return resource_table + kbpos->resno;
94 }
95
96
97
98 /****************************************************************
99  ****************** public functions ****************************
100  ****************************************************************/
101
102 /****************
103  * Register a resource (which currently may ionly be a keyring file).
104  */
105 int
106 add_keyblock_resource( const char *filename, int force, int secret )
107 {
108     IOBUF iobuf;
109     int i;
110
111     for(i=0; i < MAX_RESOURCES; i++ )
112         if( !resource_table[i].used )
113             break;
114     if( i == MAX_RESOURCES )
115         return G10ERR_RESOURCE_LIMIT;
116
117   #if __MINGW32__
118     iobuf = NULL;
119   #else
120     iobuf = iobuf_open( filename );
121     if( !iobuf && !force )
122         return G10ERR_OPEN_FILE;
123   #endif
124     resource_table[i].used = 1;
125     resource_table[i].secret = !!secret;
126     resource_table[i].fname = m_strdup(filename);
127     resource_table[i].iobuf = iobuf;
128     return 0;
129 }
130
131 /****************
132  * Return the resource name of the keyblock associated with KBPOS.
133  */
134 const char *
135 keyblock_resource_name( KBPOS *kbpos )
136 {
137     RESTBL *rentry;
138
139     if( !(rentry = check_pos( kbpos )) || !rentry->fname )
140         log_bug("no name for keyblock resource %d\n", kbpos->resno );
141     return rentry->fname;
142 }
143
144
145 /****************
146  * Get a keyblock handle KBPOS from a filename. This can be used
147  * to get a handle for insert_keyblock for a new keyblock.
148  * Using a filename of NULL returns the default resource
149  */
150 int
151 get_keyblock_handle( const char *filename, int secret, KBPOS *kbpos )
152 {
153     int i;
154
155     for(i=0; i < MAX_RESOURCES; i++ )
156         if( resource_table[i].used && !resource_table[i].secret == !secret ) {
157             /* fixme: dos needs case insensitive file compare */
158             if( !filename || !strcmp( resource_table[i].fname, filename ) ) {
159                 memset( kbpos, 0, sizeof *kbpos );
160                 kbpos->resno = i;
161                 return 0;
162             }
163         }
164     return -1; /* not found */
165 }
166
167
168 /****************
169  * Find a keyblock from the informations provided in INFO
170  * This can only be used fro public keys
171  */
172 int
173 find_keyblock( PUBKEY_FIND_INFO info, KBPOS *kbpos )
174 {
175     int i, rc, last_rc=-1;
176
177     for(i=0; i < MAX_RESOURCES; i++ ) {
178         if( resource_table[i].used && !resource_table[i].secret ) {
179             /* note: here we have to add different search functions,
180              * depending on the type of the resource */
181             rc = keyring_search2( info, kbpos, resource_table[i].fname );
182             if( !rc ) {
183                 kbpos->resno = i;
184                 kbpos->fp = NULL;
185                 return 0;
186             }
187             if( rc != -1 ) {
188                 log_error("error searching resource %d: %s\n",
189                                                   i, g10_errstr(rc));
190                 last_rc = rc;
191             }
192         }
193     }
194     return last_rc;
195 }
196
197
198
199 /****************
200  * Search a keyblock which starts with the given packet and put all
201  * informations into KBPOS, which can be used later to access this key block.
202  * This function looks into all registered keyblock sources.
203  * PACKET must be a packet with either a secret_cert or a public_cert
204  *
205  * This function is intended to check wether a given certificate
206  * is already in a keyring or to prepare it for editing.
207  *
208  * Returns: 0 if found, -1 if not found or an errorcode.
209  */
210 static int
211 search( PACKET *pkt, KBPOS *kbpos, int secret )
212 {
213     int i, rc, last_rc=-1;
214
215     for(i=0; i < MAX_RESOURCES; i++ ) {
216         if( resource_table[i].used && !resource_table[i].secret == !secret ) {
217             /* note: here we have to add different search functions,
218              * depending on the type of the resource */
219             rc = keyring_search( pkt, kbpos, resource_table[i].iobuf,
220                                              resource_table[i].fname );
221             if( !rc ) {
222                 kbpos->resno = i;
223                 kbpos->fp = NULL;
224                 return 0;
225             }
226             if( rc != -1 ) {
227                 log_error("error searching resource %d: %s\n",
228                                                   i, g10_errstr(rc));
229                 last_rc = rc;
230             }
231         }
232     }
233     return last_rc;
234 }
235
236
237 /****************
238  * Combined function to search for a username and get the position
239  * of the keyblock.
240  */
241 int
242 find_keyblock_byname( KBPOS *kbpos, const char *username )
243 {
244     PACKET pkt;
245     PKT_public_cert *pkc = m_alloc_clear( sizeof *pkc );
246     int rc;
247
248     rc = get_pubkey_byname( pkc, username );
249     if( rc ) {
250         free_public_cert(pkc);
251         return rc;
252     }
253
254     init_packet( &pkt );
255     pkt.pkttype = PKT_PUBLIC_CERT;
256     pkt.pkt.public_cert = pkc;
257     rc = search( &pkt, kbpos, 0 );
258     free_public_cert(pkc);
259     return rc;
260 }
261
262
263 /****************
264  * Combined function to search for a key and get the position
265  * of the keyblock.
266  */
267 int
268 find_keyblock_bypkc( KBPOS *kbpos, PKT_public_cert *pkc )
269 {
270     PACKET pkt;
271     int rc;
272
273     init_packet( &pkt );
274     pkt.pkttype = PKT_PUBLIC_CERT;
275     pkt.pkt.public_cert = pkc;
276     rc = search( &pkt, kbpos, 0 );
277     return rc;
278 }
279
280
281 /****************
282  * Combined function to search for a username and get the position
283  * of the keyblock. This function does not unprotect the secret key.
284  */
285 int
286 find_secret_keyblock_byname( KBPOS *kbpos, const char *username )
287 {
288     PACKET pkt;
289     PKT_secret_cert *skc = m_alloc_clear( sizeof *skc );
290     int rc;
291
292     rc = get_seckey_byname( skc, username, 0 );
293     if( rc ) {
294         free_secret_cert(skc);
295         return rc;
296     }
297
298     init_packet( &pkt );
299     pkt.pkttype = PKT_SECRET_CERT;
300     pkt.pkt.secret_cert = skc;
301     rc = search( &pkt, kbpos, 1 );
302     free_secret_cert(skc);
303     return rc;
304 }
305
306
307
308 /****************
309  * Lock the keyblock; wait until it's available
310  * This function may change the internal data in kbpos, in cases
311  * when the to be locked keyblock has been modified.
312  * fixme: remove this function and add an option to search()?
313  */
314 int
315 lock_keyblock( KBPOS *kbpos )
316 {
317     if( !check_pos(kbpos) )
318         return G10ERR_GENERAL;
319     return 0;
320 }
321
322 /****************
323  * Release a lock on a keyblock
324  */
325 void
326 unlock_keyblock( KBPOS *kbpos )
327 {
328     if( !check_pos(kbpos) )
329         BUG();
330 }
331
332 /****************
333  * Read a complete keyblock and return the root in ret_root.
334  */
335 int
336 read_keyblock( KBPOS *kbpos, KBNODE *ret_root )
337 {
338     if( !check_pos(kbpos) )
339         return G10ERR_GENERAL;
340     return keyring_read( kbpos, ret_root );
341 }
342
343
344 /****************
345  * This functions can be used to read trough a complete keyring.
346  * Mode is: 0 = open
347  *          1 = read
348  *          2 = close
349  *          5 = open secret keyrings
350  *          11 = read but skip signature and comment packets.
351  *          all others are reserved!
352  * Note that you do not need a search prior to this function,
353  * only a handle is needed.
354  * NOTE: It is not allowed to do an insert/update/delte with this
355  *       keyblock, if you want to do this, use search/read!
356  */
357 int
358 enum_keyblocks( int mode, KBPOS *kbpos, KBNODE *ret_root )
359 {
360     int rc = 0;
361     RESTBL *rentry;
362
363     if( !mode || mode == 5 || mode == 100 ) {
364         int i;
365         kbpos->fp = NULL;
366         if( !mode ) {
367             kbpos->secret = 0;
368             i = 0;
369         }
370         else if( mode == 5 ) {
371             kbpos->secret = 1;
372             mode = 0;
373             i = 0;
374         }
375         else
376             i = kbpos->resno+1;
377         for(; i < MAX_RESOURCES; i++ )
378             if( resource_table[i].used
379                 && !resource_table[i].secret == !kbpos->secret )
380                 break;
381         if( i == MAX_RESOURCES )
382             return -1; /* no resources */
383         kbpos->resno = i;
384         rentry = check_pos( kbpos );
385         kbpos->fp = iobuf_open( rentry->fname );
386         if( !kbpos->fp ) {
387             log_error("can't open '%s'\n", rentry->fname );
388             return G10ERR_OPEN_FILE;
389         }
390         kbpos->pkt = NULL;
391     }
392     else if( mode == 1 || mode == 11 ) {
393         int cont;
394         do {
395             cont = 0;
396             if( !kbpos->fp )
397                 return G10ERR_GENERAL;
398             rc = keyring_enum( kbpos, ret_root, mode == 11 );
399             if( rc == -1 ) {
400                 assert( !kbpos->pkt );
401                 rentry = check_pos( kbpos );
402                 assert(rentry);
403                 /* close */
404                 enum_keyblocks(2, kbpos, ret_root );
405                 /* and open the next one */
406                 rc = enum_keyblocks(100, kbpos, ret_root );
407                 if( !rc )
408                     cont = 1;
409             }
410         } while(cont);
411     }
412     else if( kbpos->fp ) {
413         iobuf_close( kbpos->fp );
414         kbpos->fp = NULL;
415         /* release pending packet */
416         free_packet( kbpos->pkt );
417         m_free( kbpos->pkt );
418     }
419     return rc;
420 }
421
422
423
424
425 /****************
426  * Insert the keyblock described by ROOT into the keyring described
427  * by KBPOS.  This actually appends the data to the keyfile.
428  */
429 int
430 insert_keyblock( KBPOS *kbpos, KBNODE root )
431 {
432     int rc;
433
434     if( !check_pos(kbpos) )
435         return G10ERR_GENERAL;
436
437     rc = keyring_copy( kbpos, 1, root );
438
439     return rc;
440 }
441
442 /****************
443  * Delete the keyblock described by KBPOS.
444  * The current code simply changes the keyblock in the keyring
445  * to packet of type 0 with the correct length.  To help detecting errors,
446  * zero bytes are written.
447  */
448 int
449 delete_keyblock( KBPOS *kbpos )
450 {
451     int rc;
452
453     if( !check_pos(kbpos) )
454         return G10ERR_GENERAL;
455
456     rc = keyring_copy( kbpos, 2, NULL );
457
458     return rc;
459 }
460
461
462 /****************
463  * Update the keyblock at KBPOS with the one in ROOT.
464  */
465 int
466 update_keyblock( KBPOS *kbpos, KBNODE root )
467 {
468     int rc;
469
470     if( !check_pos(kbpos) )
471         return G10ERR_GENERAL;
472
473     rc = keyring_copy( kbpos, 3, root );
474
475     return rc;
476 }
477
478
479 /****************************************************************
480  ********** Functions which operates on regular keyrings ********
481  ****************************************************************/
482
483
484 /****************
485  * search one keyring, return 0 if found, -1 if not found or an errorcode.
486  */
487 static int
488 keyring_search( PACKET *req, KBPOS *kbpos, IOBUF iobuf, const char *fname )
489 {
490     int rc;
491     PACKET pkt;
492     int save_mode;
493     ulong offset;
494     int pkttype = req->pkttype;
495     PKT_public_cert *req_pkc = req->pkt.public_cert;
496     PKT_secret_cert *req_skc = req->pkt.secret_cert;
497
498     init_packet(&pkt);
499     save_mode = set_packet_list_mode(0);
500
501   #if __MINGW32__
502     assert(!iobuf);
503     iobuf = iobuf_open( fname );
504     if( !iobuf ) {
505         log_error("%s: can't open keyring file\n", fname);
506         rc = G10ERR_KEYRING_OPEN;
507         goto leave;
508     }
509   #else
510     if( iobuf_seek( iobuf, 0 ) ) {
511         log_error("can't rewind keyring file\n");
512         rc = G10ERR_KEYRING_OPEN;
513         goto leave;
514     }
515   #endif
516
517     while( !(rc=search_packet(iobuf, &pkt, pkttype, &offset)) ) {
518         if( pkt.pkttype == PKT_SECRET_CERT ) {
519             PKT_secret_cert *skc = pkt.pkt.secret_cert;
520
521             if(   req_skc->timestamp == skc->timestamp
522                && req_skc->valid_days == skc->valid_days
523                && req_skc->pubkey_algo == skc->pubkey_algo
524                && (   ( skc->pubkey_algo == PUBKEY_ALGO_ELGAMAL
525                         && !mpi_cmp( req_skc->d.elg.p, skc->d.elg.p )
526                         && !mpi_cmp( req_skc->d.elg.g, skc->d.elg.g )
527                         && !mpi_cmp( req_skc->d.elg.y, skc->d.elg.y )
528                         && !mpi_cmp( req_skc->d.elg.x, skc->d.elg.x )
529                       )
530                    || ( skc->pubkey_algo == PUBKEY_ALGO_DSA
531                         && !mpi_cmp( req_skc->d.dsa.p, skc->d.dsa.p )
532                         && !mpi_cmp( req_skc->d.dsa.q, skc->d.dsa.q )
533                         && !mpi_cmp( req_skc->d.dsa.g, skc->d.dsa.g )
534                         && !mpi_cmp( req_skc->d.dsa.y, skc->d.dsa.y )
535                         && !mpi_cmp( req_skc->d.dsa.x, skc->d.dsa.x )
536                       )
537                    || ( skc->pubkey_algo == PUBKEY_ALGO_RSA
538                         && !mpi_cmp( req_skc->d.rsa.rsa_n, skc->d.rsa.rsa_n )
539                         && !mpi_cmp( req_skc->d.rsa.rsa_e, skc->d.rsa.rsa_e )
540                         && !mpi_cmp( req_skc->d.rsa.rsa_d, skc->d.rsa.rsa_d )
541                       )
542                   )
543               )
544                 break; /* found */
545         }
546         else if( pkt.pkttype == PKT_PUBLIC_CERT ) {
547             PKT_public_cert *pkc = pkt.pkt.public_cert;
548
549             if(   req_pkc->timestamp == pkc->timestamp
550                && req_pkc->valid_days == pkc->valid_days
551                && req_pkc->pubkey_algo == pkc->pubkey_algo
552                && (   ( pkc->pubkey_algo == PUBKEY_ALGO_ELGAMAL
553                         && !mpi_cmp( req_pkc->d.elg.p, pkc->d.elg.p )
554                         && !mpi_cmp( req_pkc->d.elg.g, pkc->d.elg.g )
555                         && !mpi_cmp( req_pkc->d.elg.y, pkc->d.elg.y )
556                       )
557                    || ( pkc->pubkey_algo == PUBKEY_ALGO_DSA
558                         && !mpi_cmp( req_pkc->d.dsa.p, pkc->d.dsa.p )
559                         && !mpi_cmp( req_pkc->d.dsa.q, pkc->d.dsa.q )
560                         && !mpi_cmp( req_pkc->d.dsa.g, pkc->d.dsa.g )
561                         && !mpi_cmp( req_pkc->d.dsa.y, pkc->d.dsa.y )
562                       )
563                    || ( pkc->pubkey_algo == PUBKEY_ALGO_RSA
564                         && !mpi_cmp( req_pkc->d.rsa.rsa_n, pkc->d.rsa.rsa_n )
565                         && !mpi_cmp( req_pkc->d.rsa.rsa_e, pkc->d.rsa.rsa_e )
566                       )
567                   )
568               )
569                 break; /* found */
570         }
571         else
572             BUG();
573         free_packet(&pkt);
574     }
575     if( !rc )
576         kbpos->offset = offset;
577
578   leave:
579     free_packet(&pkt);
580     set_packet_list_mode(save_mode);
581   #if __MINGW32__
582     iobuf_close(iobuf);
583   #endif
584     return rc;
585 }
586
587 /****************
588  * search one keyring, return 0 if found, -1 if not found or an errorcode.
589  * this version uses the finger print and other informations
590  */
591 static int
592 keyring_search2( PUBKEY_FIND_INFO info, KBPOS *kbpos, const char *fname )
593 {
594     int rc;
595     PACKET pkt;
596     int save_mode;
597     ulong offset;
598     IOBUF iobuf;
599
600     init_packet(&pkt);
601     save_mode = set_packet_list_mode(0);
602
603     iobuf = iobuf_open( fname );
604     if( !iobuf ) {
605         log_error("can't open '%s'\n", fname );
606         rc = G10ERR_OPEN_FILE;
607         goto leave;
608     }
609
610     while( !(rc=search_packet(iobuf, &pkt, PKT_PUBLIC_CERT, &offset)) ) {
611         PKT_public_cert *pkc = pkt.pkt.public_cert;
612         u32 keyid[2];
613
614         assert( pkt.pkttype == PKT_PUBLIC_CERT );
615         keyid_from_pkc( pkc, keyid );
616         if( keyid[0] == info->keyid[0] && keyid[1] == info->keyid[1]
617             && pkc->pubkey_algo == info->pubkey_algo ) {
618             /* fixme: shall we check nbits too? (good for rsa keys) */
619             /* fixme: check userid???? */
620             size_t len;
621             byte *fp = fingerprint_from_pkc( pkc, &len );
622
623             if( !memcmp( fp, info->fingerprint, len ) ) {
624                 m_free(fp);
625                 break; /* found */
626             }
627             m_free(fp);
628         }
629         free_packet(&pkt);
630     }
631     if( !rc )
632         kbpos->offset = offset;
633
634   leave:
635     iobuf_close(iobuf);
636     free_packet(&pkt);
637     set_packet_list_mode(save_mode);
638     return rc;
639 }
640
641
642 static int
643 keyring_read( KBPOS *kbpos, KBNODE *ret_root )
644 {
645     PACKET *pkt;
646     int rc;
647     RESTBL *rentry;
648     KBNODE root = NULL;
649     IOBUF a;
650     int in_cert = 0;
651
652     if( !(rentry=check_pos(kbpos)) )
653         return G10ERR_GENERAL;
654
655     a = iobuf_open( rentry->fname );
656     if( !a ) {
657         log_error("can't open '%s'\n", rentry->fname );
658         return G10ERR_OPEN_FILE;
659     }
660
661     if( iobuf_seek( a, kbpos->offset ) ) {
662         log_error("can't seek to %lu\n", kbpos->offset);
663         iobuf_close(a);
664         return G10ERR_KEYRING_OPEN;
665     }
666
667     pkt = m_alloc( sizeof *pkt );
668     init_packet(pkt);
669     kbpos->count=0;
670     while( (rc=parse_packet(a, pkt)) != -1 ) {
671         if( rc ) {  /* ignore errors */
672             if( rc != G10ERR_UNKNOWN_PACKET ) {
673                 log_error("read_keyblock: read error: %s\n", g10_errstr(rc) );
674                 rc = G10ERR_INV_KEYRING;
675                 goto ready;
676             }
677                 log_info("read_keyblock: read error: %s\n", g10_errstr(rc) );
678             kbpos->count++;
679             free_packet( pkt );
680             init_packet( pkt );
681             continue;
682         }
683         /* make a linked list of all packets */
684         switch( pkt->pkttype ) {
685           case PKT_PUBLIC_CERT:
686           case PKT_SECRET_CERT:
687             if( in_cert )
688                 goto ready;
689             in_cert = 1;
690           default:
691             kbpos->count++;
692             if( !root )
693                 root = new_kbnode( pkt );
694             else
695                 add_kbnode( root, new_kbnode( pkt ) );
696             pkt = m_alloc( sizeof *pkt );
697             init_packet(pkt);
698             break;
699         }
700     }
701   ready:
702     if( rc == -1 && root )
703         rc = 0;
704
705     if( rc )
706         release_kbnode( root );
707     else
708         *ret_root = root;
709     free_packet( pkt );
710     m_free( pkt );
711     iobuf_close(a);
712     return rc;
713 }
714
715
716 static int
717 keyring_enum( KBPOS *kbpos, KBNODE *ret_root, int skipsigs )
718 {
719     PACKET *pkt;
720     int rc;
721     RESTBL *rentry;
722     KBNODE root = NULL;
723
724     if( !(rentry=check_pos(kbpos)) )
725         return G10ERR_GENERAL;
726
727     if( kbpos->pkt ) {
728         root = new_kbnode( kbpos->pkt );
729         kbpos->pkt = NULL;
730     }
731
732     pkt = m_alloc( sizeof *pkt );
733     init_packet(pkt);
734     while( (rc=parse_packet(kbpos->fp, pkt)) != -1 ) {
735         if( rc ) {  /* ignore errors */
736             if( rc != G10ERR_UNKNOWN_PACKET ) {
737                 log_error("read_keyblock: read error: %s\n", g10_errstr(rc) );
738                 rc = G10ERR_INV_KEYRING;
739                 goto ready;
740             }
741             free_packet( pkt );
742             init_packet( pkt );
743             continue;
744         }
745         /* make a linked list of all packets */
746         switch( pkt->pkttype ) {
747           case PKT_PUBLIC_CERT:
748           case PKT_SECRET_CERT:
749             if( root ) { /* store this packet */
750                 kbpos->pkt = pkt;
751                 pkt = NULL;
752                 goto ready;
753             }
754             root = new_kbnode( pkt );
755             pkt = m_alloc( sizeof *pkt );
756             init_packet(pkt);
757             break;
758
759           default:
760             /* skip pakets at the begin of a keyring, until we find
761              * a start packet; issue a warning if it is not a comment */
762             if( !root && pkt->pkttype != PKT_COMMENT )
763                 log_info("keyring_enum: skipped packet of type %d\n",
764                             pkt->pkttype );
765             if( !root || (skipsigs && ( pkt->pkttype == PKT_SIGNATURE
766                                       ||pkt->pkttype == PKT_COMMENT )) ) {
767                 init_packet(pkt);
768                 break;
769             }
770             add_kbnode( root, new_kbnode( pkt ) );
771             pkt = m_alloc( sizeof *pkt );
772             init_packet(pkt);
773             break;
774         }
775     }
776   ready:
777     if( rc == -1 && root )
778         rc = 0;
779
780     if( rc )
781         release_kbnode( root );
782     else
783         *ret_root = root;
784     free_packet( pkt );
785     m_free( pkt );
786     return rc;
787 }
788
789
790
791 /****************
792  * Peromf insert/delete/update operation.
793  * mode 1 = insert
794  *      2 = delete
795  *      3 = update
796  */
797 static int
798 keyring_copy( KBPOS *kbpos, int mode, KBNODE root )
799 {
800     RESTBL *rentry;
801     IOBUF fp, newfp;
802     int rc=0;
803     char *bakfname = NULL;
804     char *tmpfname = NULL;
805
806     if( !(rentry = check_pos( kbpos )) )
807         return G10ERR_GENERAL;
808     if( kbpos->fp )
809         BUG(); /* not allowed with such a handle */
810
811     /* open the source file */
812     fp = iobuf_open( rentry->fname );
813     if( mode == 1 && !fp && errno == ENOENT ) { /* no file yet */
814         KBNODE kbctx, node;
815
816         /* insert: create a new file */
817         newfp = iobuf_create( rentry->fname );
818         if( !newfp ) {
819             log_error("%s: can't create: %s\n", rentry->fname, strerror(errno));
820             return G10ERR_OPEN_FILE;
821         }
822
823         kbctx=NULL;
824         while( (node = walk_kbnode( root, &kbctx, 0 )) ) {
825             if( (rc = build_packet( newfp, node->pkt )) ) {
826                 log_error("build_packet(%d) failed: %s\n",
827                             node->pkt->pkttype, g10_errstr(rc) );
828                 iobuf_cancel(newfp);
829                 return G10ERR_WRITE_FILE;
830             }
831         }
832         if( iobuf_close(newfp) ) {
833             log_error("%s: close failed: %s\n", rentry->fname, strerror(errno));
834             return G10ERR_CLOSE_FILE;
835         }
836         if( chmod( rentry->fname, S_IRUSR | S_IWUSR ) ) {
837             log_error("%s: chmod failed: %s\n",
838                                     rentry->fname, strerror(errno) );
839             return G10ERR_WRITE_FILE;
840         }
841         return 0;
842     }
843     if( !fp ) {
844         log_error("%s: can't open: %s\n", rentry->fname, strerror(errno) );
845         rc = G10ERR_OPEN_FILE;
846         goto leave;
847     }
848
849     /* create the new file */
850     bakfname = m_alloc( strlen( rentry->fname ) + 2 );
851     strcpy(stpcpy(bakfname,rentry->fname),"~");
852     tmpfname = m_alloc( strlen( rentry->fname ) + 5 );
853     strcpy(stpcpy(tmpfname,rentry->fname),".tmp");
854     newfp = iobuf_create( tmpfname );
855     if( !newfp ) {
856         log_error("%s: can't create: %s\n", tmpfname, strerror(errno) );
857         iobuf_close(fp);
858         rc = G10ERR_OPEN_FILE;
859         goto leave;
860     }
861
862     if( mode == 1 ) { /* insert */
863         /* copy everything to the new file */
864         rc = copy_all_packets( fp, newfp );
865         if( rc != -1 ) {
866             log_error("%s: copy to %s failed: %s\n",
867                       rentry->fname, tmpfname, g10_errstr(rc) );
868             iobuf_close(fp);
869             iobuf_cancel(newfp);
870             goto leave;
871         }
872         rc = 0;
873     }
874
875     if( mode == 2 || mode == 3 ) { /* delete or update */
876         /* copy first part to the new file */
877         rc = copy_some_packets( fp, newfp, kbpos->offset );
878         if( rc ) { /* should never get EOF here */
879             log_error("%s: copy to %s failed: %s\n",
880                       rentry->fname, tmpfname, g10_errstr(rc) );
881             iobuf_close(fp);
882             iobuf_cancel(newfp);
883             goto leave;
884         }
885         /* skip this keyblock */
886         assert( kbpos->count );
887         rc = skip_some_packets( fp, kbpos->count );
888         if( rc ) {
889             log_error("%s: skipping %u packets failed: %s\n",
890                             rentry->fname, kbpos->count, g10_errstr(rc));
891             iobuf_close(fp);
892             iobuf_cancel(newfp);
893             goto leave;
894         }
895     }
896
897     if( mode == 1 || mode == 3 ) { /* insert or update */
898         KBNODE kbctx, node;
899
900         /* append the new data */
901         kbctx=NULL;
902         while( (node = walk_kbnode( root, &kbctx, 0 )) ) {
903             if( (rc = build_packet( newfp, node->pkt )) ) {
904                 log_error("build_packet(%d) failed: %s\n",
905                             node->pkt->pkttype, g10_errstr(rc) );
906                 iobuf_close(fp);
907                 iobuf_cancel(newfp);
908                 rc = G10ERR_WRITE_FILE;
909                 goto leave;
910             }
911         }
912     }
913
914     if( mode == 2 || mode == 3 ) { /* delete or update */
915         /* copy the rest */
916         rc = copy_all_packets( fp, newfp );
917         if( rc != -1 ) {
918             log_error("%s: copy to %s failed: %s\n",
919                       rentry->fname, tmpfname, g10_errstr(rc) );
920             iobuf_close(fp);
921             iobuf_cancel(newfp);
922             goto leave;
923         }
924         rc = 0;
925     }
926
927     /* close both files */
928     if( iobuf_close(fp) ) {
929         log_error("%s: close failed: %s\n", rentry->fname, strerror(errno) );
930         rc = G10ERR_CLOSE_FILE;
931         goto leave;
932     }
933     if( iobuf_close(newfp) ) {
934         log_error("%s: close failed: %s\n", tmpfname, strerror(errno) );
935         rc = G10ERR_CLOSE_FILE;
936         goto leave;
937     }
938     /* if the new file is a secring, restrict the permissions */
939     if( rentry->secret ) {
940         if( chmod( tmpfname, S_IRUSR | S_IWUSR ) ) {
941             log_error("%s: chmod failed: %s\n",
942                                     tmpfname, strerror(errno) );
943             rc = G10ERR_WRITE_FILE;
944             goto leave;
945         }
946     }
947     /* rename and make backup file */
948   #if __MINGW32__
949     remove( bakfname );
950   #endif
951     if( rename( rentry->fname, bakfname ) ) {
952         log_error("%s: rename to %s failed: %s\n",
953                                 rentry->fname, bakfname, strerror(errno) );
954         rc = G10ERR_RENAME_FILE;
955         goto leave;
956     }
957   #if __MINGW32__
958     remove( rentry->fname );
959   #endif
960     if( rename( tmpfname, rentry->fname ) ) {
961         log_error("%s: rename to %s failed: %s\n",
962                             tmpfname, rentry->fname,strerror(errno) );
963         rc = G10ERR_RENAME_FILE;
964         goto leave;
965     }
966
967   leave:
968     m_free(bakfname);
969     m_free(tmpfname);
970     return rc;
971 }
972
973
974 /****************************************************************
975  ********** Functions which operates on databases ***************
976  ****************************************************************/
977