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