g10: Fix the show old policy functionality when changing a TOFU policy.
[gnupg.git] / kbx / keybox-update.c
1 /* keybox-update.c - keybox update operations
2  * Copyright (C) 2001, 2003, 2004, 2012 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 3 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, see <http://www.gnu.org/licenses/>.
18  */
19
20 #include <config.h>
21 #include <stdlib.h>
22 #include <stdio.h>
23 #include <string.h>
24 #include <errno.h>
25 #include <time.h>
26 #include <unistd.h>
27 #include <assert.h>
28
29 #include "keybox-defs.h"
30 #include "../common/sysutils.h"
31 #include "../common/host2net.h"
32 #include "../common/utilproto.h"
33
34 #define EXTSEP_S "."
35
36 #define FILECOPY_INSERT 1
37 #define FILECOPY_DELETE 2
38 #define FILECOPY_UPDATE 3
39
40
41 #if !defined(HAVE_FSEEKO) && !defined(fseeko)
42
43 #ifdef HAVE_LIMITS_H
44 # include <limits.h>
45 #endif
46 #ifndef LONG_MAX
47 # define LONG_MAX ((long) ((unsigned long) -1 >> 1))
48 #endif
49 #ifndef LONG_MIN
50 # define LONG_MIN (-1 - LONG_MAX)
51 #endif
52
53 /****************
54  * A substitute for fseeko, for hosts that don't have it.
55  */
56 static int
57 fseeko (FILE * stream, off_t newpos, int whence)
58 {
59   while (newpos != (long) newpos)
60     {
61       long pos = newpos < 0 ? LONG_MIN : LONG_MAX;
62       if (fseek (stream, pos, whence) != 0)
63         return -1;
64       newpos -= pos;
65       whence = SEEK_CUR;
66     }
67   return fseek (stream, (long) newpos, whence);
68 }
69 #endif /* !defined(HAVE_FSEEKO) && !defined(fseeko) */
70
71
72 static int
73 create_tmp_file (const char *template,
74                  char **r_bakfname, char **r_tmpfname, FILE **r_fp)
75 {
76   gpg_error_t err;
77
78   err = keybox_tmp_names (template, 0, r_bakfname, r_tmpfname);
79   if (!err)
80     {
81       *r_fp = fopen (*r_tmpfname, "wb");
82       if (!*r_fp)
83         {
84           err = gpg_error_from_syserror ();
85           xfree (*r_tmpfname);
86           *r_tmpfname = NULL;
87           xfree (*r_bakfname);
88           *r_bakfname = NULL;
89         }
90     }
91
92   return err;
93 }
94
95
96 static int
97 rename_tmp_file (const char *bakfname, const char *tmpfname,
98                  const char *fname, int secret )
99 {
100   int rc=0;
101   int block = 0;
102
103   /* restrict the permissions for secret keyboxs */
104 #ifndef HAVE_DOSISH_SYSTEM
105 /*    if (secret && !opt.preserve_permissions) */
106 /*      { */
107 /*        if (chmod (tmpfname, S_IRUSR | S_IWUSR) )  */
108 /*          { */
109 /*            log_debug ("chmod of '%s' failed: %s\n", */
110 /*                       tmpfname, strerror(errno) ); */
111 /*            return KEYBOX_Write_File; */
112 /*      } */
113 /*      } */
114 #endif
115
116   /* fixme: invalidate close caches (not used with stdio)*/
117 /*    iobuf_ioctl (NULL, IOBUF_IOCTL_INVALIDATE_CACHE, 0, (char*)tmpfname ); */
118 /*    iobuf_ioctl (NULL, IOBUF_IOCTL_INVALIDATE_CACHE, 0, (char*)bakfname ); */
119 /*    iobuf_ioctl (NULL, IOBUF_IOCTL_INVALIDATE_CACHE, 0, (char*)fname ); */
120
121   /* First make a backup file except for secret keyboxes. */
122   if (!secret)
123     {
124       block = 1;
125       rc = keybox_file_rename (fname, bakfname, &block);
126       if (rc)
127         goto leave;
128     }
129
130   /* Then rename the file. */
131   rc = keybox_file_rename (tmpfname, fname, NULL);
132   if (block)
133     {
134       gnupg_unblock_all_signals ();
135       block = 0;
136     }
137   /* if (rc) */
138   /*   { */
139   /*     if (secret) */
140   /*       { */
141   /*         log_info ("WARNING: 2 files with confidential" */
142   /*                   " information exists.\n"); */
143   /*         log_info ("%s is the unchanged one\n", fname ); */
144   /*         log_info ("%s is the new one\n", tmpfname ); */
145   /*         log_info ("Please fix this possible security flaw\n"); */
146   /*       } */
147   /*   } */
148
149  leave:
150   if (block)
151     gnupg_unblock_all_signals ();
152   return rc;
153 }
154
155
156
157 /* Perform insert/delete/update operation.  MODE is one of
158    FILECOPY_INSERT, FILECOPY_DELETE, FILECOPY_UPDATE.  FOR_OPENPGP
159    indicates that this is called due to an OpenPGP keyblock change.  */
160 static int
161 blob_filecopy (int mode, const char *fname, KEYBOXBLOB blob,
162                int secret, int for_openpgp, off_t start_offset)
163 {
164   FILE *fp, *newfp;
165   int rc=0;
166   char *bakfname = NULL;
167   char *tmpfname = NULL;
168   char buffer[4096];  /* (Must be at least 32 bytes) */
169   int nread, nbytes;
170
171   /* Open the source file. Because we do a rename, we have to check the
172      permissions of the file */
173   if (access (fname, W_OK))
174     return gpg_error_from_syserror ();
175
176   fp = fopen (fname, "rb");
177   if (mode == FILECOPY_INSERT && !fp && errno == ENOENT)
178     {
179       /* Insert mode but file does not exist:
180          Create a new keybox file. */
181       newfp = fopen (fname, "wb");
182       if (!newfp )
183         return gpg_error_from_syserror ();
184
185       rc = _keybox_write_header_blob (newfp, for_openpgp);
186       if (rc)
187         {
188           fclose (newfp);
189           return rc;
190         }
191
192       rc = _keybox_write_blob (blob, newfp);
193       if (rc)
194         {
195           fclose (newfp);
196           return rc;
197         }
198
199       if ( fclose (newfp) )
200         return gpg_error_from_syserror ();
201
202 /*        if (chmod( fname, S_IRUSR | S_IWUSR )) */
203 /*          { */
204 /*            log_debug ("%s: chmod failed: %s\n", fname, strerror(errno) ); */
205 /*            return KEYBOX_File_Error; */
206 /*          } */
207       return 0; /* Ready. */
208     }
209
210   if (!fp)
211     {
212       rc = gpg_error_from_syserror ();
213       goto leave;
214     }
215
216   /* Create the new file.  On success NEWFP is initialized.  */
217   rc = create_tmp_file (fname, &bakfname, &tmpfname, &newfp);
218   if (rc)
219     {
220       fclose (fp);
221       goto leave;
222     }
223
224   /* prepare for insert */
225   if (mode == FILECOPY_INSERT)
226     {
227       int first_record = 1;
228
229       /* Copy everything to the new file.  If this is for OpenPGP, we
230          make sure that the openpgp flag is set in the header.  (We
231          failsafe the blob type.) */
232       while ( (nread = fread (buffer, 1, DIM(buffer), fp)) > 0 )
233         {
234           if (first_record && for_openpgp
235               && buffer[4] == KEYBOX_BLOBTYPE_HEADER)
236             {
237               first_record = 0;
238               buffer[7] |= 0x02; /* OpenPGP data may be available.  */
239             }
240
241           if (fwrite (buffer, nread, 1, newfp) != 1)
242             {
243               rc = gpg_error_from_syserror ();
244               fclose (fp);
245               fclose (newfp);
246               goto leave;
247             }
248         }
249       if (ferror (fp))
250         {
251           rc = gpg_error_from_syserror ();
252           fclose (fp);
253           fclose (newfp);
254           goto leave;
255         }
256     }
257
258   /* Prepare for delete or update. */
259   if ( mode == FILECOPY_DELETE || mode == FILECOPY_UPDATE )
260     {
261       off_t current = 0;
262
263       /* Copy first part to the new file. */
264       while ( current < start_offset )
265         {
266           nbytes = DIM(buffer);
267           if (current + nbytes > start_offset)
268               nbytes = start_offset - current;
269           nread = fread (buffer, 1, nbytes, fp);
270           if (!nread)
271             break;
272           current += nread;
273
274           if (fwrite (buffer, nread, 1, newfp) != 1)
275             {
276               rc = gpg_error_from_syserror ();
277               fclose (fp);
278               fclose (newfp);
279               goto leave;
280             }
281         }
282       if (ferror (fp))
283         {
284           rc = gpg_error_from_syserror ();
285           fclose (fp);
286           fclose (newfp);
287           goto leave;
288         }
289
290       /* Skip this blob. */
291       rc = _keybox_read_blob (NULL, fp);
292       if (rc)
293         {
294           fclose (fp);
295           fclose (newfp);
296           return rc;
297         }
298     }
299
300   /* Do an insert or update. */
301   if ( mode == FILECOPY_INSERT || mode == FILECOPY_UPDATE )
302     {
303       rc = _keybox_write_blob (blob, newfp);
304       if (rc)
305         {
306           fclose (fp);
307           fclose (newfp);
308           return rc;
309         }
310     }
311
312   /* Copy the rest of the packet for an delete or update. */
313   if (mode == FILECOPY_DELETE || mode == FILECOPY_UPDATE)
314     {
315       while ( (nread = fread (buffer, 1, DIM(buffer), fp)) > 0 )
316         {
317           if (fwrite (buffer, nread, 1, newfp) != 1)
318             {
319               rc = gpg_error_from_syserror ();
320               fclose (fp);
321               fclose (newfp);
322               goto leave;
323             }
324         }
325       if (ferror (fp))
326         {
327           rc = gpg_error_from_syserror ();
328           fclose (fp);
329           fclose (newfp);
330           goto leave;
331         }
332     }
333
334   /* Close both files. */
335   if (fclose(fp))
336     {
337       rc = gpg_error_from_syserror ();
338       fclose (newfp);
339       goto leave;
340     }
341   if (fclose(newfp))
342     {
343       rc = gpg_error_from_syserror ();
344       goto leave;
345     }
346
347   rc = rename_tmp_file (bakfname, tmpfname, fname, secret);
348
349  leave:
350   xfree(bakfname);
351   xfree(tmpfname);
352   return rc;
353 }
354
355
356 /* Insert the OpenPGP keyblock {IMAGE,IMAGELEN} into HD.  SIGSTATUS is
357    a vector describing the status of the signatures; its first element
358    gives the number of following elements.  */
359 gpg_error_t
360 keybox_insert_keyblock (KEYBOX_HANDLE hd, const void *image, size_t imagelen,
361                         u32 *sigstatus)
362 {
363   gpg_error_t err;
364   const char *fname;
365   KEYBOXBLOB blob;
366   size_t nparsed;
367   struct _keybox_openpgp_info info;
368
369   if (!hd)
370     return gpg_error (GPG_ERR_INV_HANDLE);
371   if (!hd->kb)
372     return gpg_error (GPG_ERR_INV_HANDLE);
373   fname = hd->kb->fname;
374   if (!fname)
375     return gpg_error (GPG_ERR_INV_HANDLE);
376
377
378   /* Close this one otherwise we will mess up the position for a next
379      search.  Fixme: it would be better to adjust the position after
380      the write operation.  */
381   _keybox_close_file (hd);
382
383   err = _keybox_parse_openpgp (image, imagelen, &nparsed, &info);
384   if (err)
385     return err;
386   assert (nparsed <= imagelen);
387   err = _keybox_create_openpgp_blob (&blob, &info, image, imagelen,
388                                      sigstatus, hd->ephemeral);
389   _keybox_destroy_openpgp_info (&info);
390   if (!err)
391     {
392       err = blob_filecopy (FILECOPY_INSERT, fname, blob, hd->secret, 1, 0);
393       _keybox_release_blob (blob);
394       /*    if (!rc && !hd->secret && kb_offtbl) */
395       /*      { */
396       /*        update_offset_hash_table_from_kb (kb_offtbl, kb, 0); */
397       /*      } */
398     }
399   return err;
400 }
401
402
403 /* Update the current key at HD with the given OpenPGP keyblock in
404    {IMAGE,IMAGELEN}.  */
405 gpg_error_t
406 keybox_update_keyblock (KEYBOX_HANDLE hd, const void *image, size_t imagelen)
407 {
408   gpg_error_t err;
409   const char *fname;
410   off_t off;
411   KEYBOXBLOB blob;
412   size_t nparsed;
413   struct _keybox_openpgp_info info;
414
415   if (!hd || !image || !imagelen)
416     return gpg_error (GPG_ERR_INV_VALUE);
417   if (!hd->found.blob)
418     return gpg_error (GPG_ERR_NOTHING_FOUND);
419   if (blob_get_type (hd->found.blob) != KEYBOX_BLOBTYPE_PGP)
420     return gpg_error (GPG_ERR_WRONG_BLOB_TYPE);
421   fname = hd->kb->fname;
422   if (!fname)
423     return gpg_error (GPG_ERR_INV_HANDLE);
424
425   off = _keybox_get_blob_fileoffset (hd->found.blob);
426   if (off == (off_t)-1)
427     return gpg_error (GPG_ERR_GENERAL);
428
429   /* Close this the file so that we do no mess up the position for a
430      next search.  */
431   _keybox_close_file (hd);
432
433   /* Build a new blob.  */
434   err = _keybox_parse_openpgp (image, imagelen, &nparsed, &info);
435   if (err)
436     return err;
437   assert (nparsed <= imagelen);
438   err = _keybox_create_openpgp_blob (&blob, &info, image, imagelen,
439                                      NULL, hd->ephemeral);
440   _keybox_destroy_openpgp_info (&info);
441
442   /* Update the keyblock.  */
443   if (!err)
444     {
445       err = blob_filecopy (FILECOPY_UPDATE, fname, blob, hd->secret, 1, off);
446       _keybox_release_blob (blob);
447     }
448   return err;
449 }
450
451
452
453 #ifdef KEYBOX_WITH_X509
454 int
455 keybox_insert_cert (KEYBOX_HANDLE hd, ksba_cert_t cert,
456                     unsigned char *sha1_digest)
457 {
458   int rc;
459   const char *fname;
460   KEYBOXBLOB blob;
461
462   if (!hd)
463     return gpg_error (GPG_ERR_INV_HANDLE);
464   if (!hd->kb)
465     return gpg_error (GPG_ERR_INV_HANDLE);
466   fname = hd->kb->fname;
467   if (!fname)
468     return gpg_error (GPG_ERR_INV_HANDLE);
469
470   /* Close this one otherwise we will mess up the position for a next
471      search.  Fixme: it would be better to adjust the position after
472      the write operation.  */
473   _keybox_close_file (hd);
474
475   rc = _keybox_create_x509_blob (&blob, cert, sha1_digest, hd->ephemeral);
476   if (!rc)
477     {
478       rc = blob_filecopy (FILECOPY_INSERT, fname, blob, hd->secret, 0, 0);
479       _keybox_release_blob (blob);
480       /*    if (!rc && !hd->secret && kb_offtbl) */
481       /*      { */
482       /*        update_offset_hash_table_from_kb (kb_offtbl, kb, 0); */
483       /*      } */
484     }
485   return rc;
486 }
487
488 int
489 keybox_update_cert (KEYBOX_HANDLE hd, ksba_cert_t cert,
490                     unsigned char *sha1_digest)
491 {
492   (void)hd;
493   (void)cert;
494   (void)sha1_digest;
495   return -1;
496 }
497
498
499 #endif /*KEYBOX_WITH_X509*/
500
501 /* Note: We assume that the keybox has been locked before the current
502    search was executed.  This is needed so that we can depend on the
503    offset information of the flags. */
504 int
505 keybox_set_flags (KEYBOX_HANDLE hd, int what, int idx, unsigned int value)
506 {
507   off_t off;
508   const char *fname;
509   FILE *fp;
510   gpg_err_code_t ec;
511   size_t flag_pos, flag_size;
512   const unsigned char *buffer;
513   size_t length;
514
515   (void)idx;  /* Not yet used.  */
516
517   if (!hd)
518     return gpg_error (GPG_ERR_INV_VALUE);
519   if (!hd->found.blob)
520     return gpg_error (GPG_ERR_NOTHING_FOUND);
521   if (!hd->kb)
522     return gpg_error (GPG_ERR_INV_HANDLE);
523   if (!hd->found.blob)
524     return gpg_error (GPG_ERR_NOTHING_FOUND);
525   fname = hd->kb->fname;
526   if (!fname)
527     return gpg_error (GPG_ERR_INV_HANDLE);
528
529   off = _keybox_get_blob_fileoffset (hd->found.blob);
530   if (off == (off_t)-1)
531     return gpg_error (GPG_ERR_GENERAL);
532
533   buffer = _keybox_get_blob_image (hd->found.blob, &length);
534   ec = _keybox_get_flag_location (buffer, length, what, &flag_pos, &flag_size);
535   if (ec)
536     return gpg_error (ec);
537
538   off += flag_pos;
539
540   _keybox_close_file (hd);
541   fp = fopen (hd->kb->fname, "r+b");
542   if (!fp)
543     return gpg_error_from_syserror ();
544
545   ec = 0;
546   if (fseeko (fp, off, SEEK_SET))
547     ec = gpg_err_code_from_syserror ();
548   else
549     {
550       unsigned char tmp[4];
551
552       tmp[0] = value >> 24;
553       tmp[1] = value >> 16;
554       tmp[2] = value >>  8;
555       tmp[3] = value;
556
557       switch (flag_size)
558         {
559         case 1:
560         case 2:
561         case 4:
562           if (fwrite (tmp+4-flag_size, flag_size, 1, fp) != 1)
563             ec = gpg_err_code_from_syserror ();
564           break;
565         default:
566           ec = GPG_ERR_BUG;
567           break;
568         }
569     }
570
571   if (fclose (fp))
572     {
573       if (!ec)
574         ec = gpg_err_code_from_syserror ();
575     }
576
577   return gpg_error (ec);
578 }
579
580
581
582 int
583 keybox_delete (KEYBOX_HANDLE hd)
584 {
585   off_t off;
586   const char *fname;
587   FILE *fp;
588   int rc;
589
590   if (!hd)
591     return gpg_error (GPG_ERR_INV_VALUE);
592   if (!hd->found.blob)
593     return gpg_error (GPG_ERR_NOTHING_FOUND);
594   if (!hd->kb)
595     return gpg_error (GPG_ERR_INV_HANDLE);
596   fname = hd->kb->fname;
597   if (!fname)
598     return gpg_error (GPG_ERR_INV_HANDLE);
599
600   off = _keybox_get_blob_fileoffset (hd->found.blob);
601   if (off == (off_t)-1)
602     return gpg_error (GPG_ERR_GENERAL);
603   off += 4;
604
605   _keybox_close_file (hd);
606   fp = fopen (hd->kb->fname, "r+b");
607   if (!fp)
608     return gpg_error_from_syserror ();
609
610   if (fseeko (fp, off, SEEK_SET))
611     rc = gpg_error_from_syserror ();
612   else if (putc (0, fp) == EOF)
613     rc = gpg_error_from_syserror ();
614   else
615     rc = 0;
616
617   if (fclose (fp))
618     {
619       if (!rc)
620         rc = gpg_error_from_syserror ();
621     }
622
623   return rc;
624 }
625
626
627 /* Compress the keybox file.  This should be run with the file
628    locked. */
629 int
630 keybox_compress (KEYBOX_HANDLE hd)
631 {
632   int read_rc, rc;
633   const char *fname;
634   FILE *fp, *newfp;
635   char *bakfname = NULL;
636   char *tmpfname = NULL;
637   int first_blob;
638   KEYBOXBLOB blob = NULL;
639   u32 cut_time;
640   int any_changes = 0;
641   int skipped_deleted;
642
643   if (!hd)
644     return gpg_error (GPG_ERR_INV_HANDLE);
645   if (!hd->kb)
646     return gpg_error (GPG_ERR_INV_HANDLE);
647   if (hd->secret)
648     return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
649   fname = hd->kb->fname;
650   if (!fname)
651     return gpg_error (GPG_ERR_INV_HANDLE);
652
653   _keybox_close_file (hd);
654
655   /* Open the source file. Because we do a rename, we have to check the
656      permissions of the file */
657   if (access (fname, W_OK))
658     return gpg_error_from_syserror ();
659
660   fp = fopen (fname, "rb");
661   if (!fp && errno == ENOENT)
662     return 0; /* Ready. File has been deleted right after the access above. */
663   if (!fp)
664     {
665       rc = gpg_error_from_syserror ();
666       return rc;
667     }
668
669   /* A quick test to see if we need to compress the file at all.  We
670      schedule a compress run after 3 hours. */
671   if ( !_keybox_read_blob (&blob, fp) )
672     {
673       const unsigned char *buffer;
674       size_t length;
675
676       buffer = _keybox_get_blob_image (blob, &length);
677       if (length > 4 && buffer[4] == KEYBOX_BLOBTYPE_HEADER)
678         {
679           u32 last_maint = buf32_to_u32 (buffer+20);
680
681           if ( (last_maint + 3*3600) > time (NULL) )
682             {
683               fclose (fp);
684               _keybox_release_blob (blob);
685               return 0; /* Compress run not yet needed. */
686             }
687         }
688       _keybox_release_blob (blob);
689       fseek (fp, 0, SEEK_SET);
690       clearerr (fp);
691     }
692
693   /* Create the new file. */
694   rc = create_tmp_file (fname, &bakfname, &tmpfname, &newfp);
695   if (rc)
696     {
697       fclose (fp);
698       return rc;;
699     }
700
701
702   /* Processing loop.  By reading using _keybox_read_blob we
703      automagically skip any blobs flagged as deleted.  Thus what we
704      only have to do is to check all ephemeral flagged blocks whether
705      their time has come and write out all other blobs. */
706   cut_time = time(NULL) - 86400;
707   first_blob = 1;
708   skipped_deleted = 0;
709   for (rc=0; !(read_rc = _keybox_read_blob2 (&blob, fp, &skipped_deleted));
710        _keybox_release_blob (blob), blob = NULL )
711     {
712       unsigned int blobflags;
713       const unsigned char *buffer;
714       size_t length, pos, size;
715       u32 created_at;
716
717       if (skipped_deleted)
718         any_changes = 1;
719       buffer = _keybox_get_blob_image (blob, &length);
720       if (first_blob)
721         {
722           first_blob = 0;
723           if (length > 4 && buffer[4] == KEYBOX_BLOBTYPE_HEADER)
724             {
725               /* Write out the blob with an updated maintenance time
726                  stamp and if needed (ie. used by gpg) set the openpgp
727                  flag.  */
728               _keybox_update_header_blob (blob, hd->for_openpgp);
729               rc = _keybox_write_blob (blob, newfp);
730               if (rc)
731                 break;
732               continue;
733             }
734
735           /* The header blob is missing.  Insert it.  */
736           rc = _keybox_write_header_blob (newfp, hd->for_openpgp);
737           if (rc)
738             break;
739           any_changes = 1;
740         }
741       else if (length > 4 && buffer[4] == KEYBOX_BLOBTYPE_HEADER)
742         {
743           /* Oops: There is another header record - remove it. */
744           any_changes = 1;
745           continue;
746         }
747
748       if (_keybox_get_flag_location (buffer, length,
749                                      KEYBOX_FLAG_BLOB, &pos, &size)
750           || size != 2)
751         {
752           rc = gpg_error (GPG_ERR_BUG);
753           break;
754         }
755       blobflags = buf16_to_uint (buffer+pos);
756       if ((blobflags & KEYBOX_FLAG_BLOB_EPHEMERAL))
757         {
758           /* This is an ephemeral blob. */
759           if (_keybox_get_flag_location (buffer, length,
760                                          KEYBOX_FLAG_CREATED_AT, &pos, &size)
761               || size != 4)
762             created_at = 0; /* oops. */
763           else
764             created_at = buf32_to_u32 (buffer+pos);
765
766           if (created_at && created_at < cut_time)
767             {
768               any_changes = 1;
769               continue; /* Skip this blob. */
770             }
771         }
772
773       rc = _keybox_write_blob (blob, newfp);
774       if (rc)
775         break;
776     }
777   if (skipped_deleted)
778     any_changes = 1;
779   _keybox_release_blob (blob); blob = NULL;
780   if (!rc && read_rc == -1)
781     rc = 0;
782   else if (!rc)
783     rc = read_rc;
784
785   /* Close both files. */
786   if (fclose(fp) && !rc)
787     rc = gpg_error_from_syserror ();
788   if (fclose(newfp) && !rc)
789     rc = gpg_error_from_syserror ();
790
791   /* Rename or remove the temporary file. */
792   if (rc || !any_changes)
793     gnupg_remove (tmpfname);
794   else
795     rc = rename_tmp_file (bakfname, tmpfname, fname, hd->secret);
796
797   xfree(bakfname);
798   xfree(tmpfname);
799   return rc;
800 }