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