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