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