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