LCOV - code coverage report
Current view: top level - kbx - keybox-update.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 148 347 42.7 %
Date: 2016-11-29 15:00:56 Functions: 8 10 80.0 %

          Line data    Source code
       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 <https://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         165 : create_tmp_file (const char *template,
      74             :                  char **r_bakfname, char **r_tmpfname, FILE **r_fp)
      75             : {
      76             :   gpg_error_t err;
      77             : 
      78         165 :   err = keybox_tmp_names (template, 0, r_bakfname, r_tmpfname);
      79         165 :   if (!err)
      80             :     {
      81         165 :       *r_fp = fopen (*r_tmpfname, "wb");
      82         165 :       if (!*r_fp)
      83             :         {
      84           0 :           err = gpg_error_from_syserror ();
      85           0 :           xfree (*r_tmpfname);
      86           0 :           *r_tmpfname = NULL;
      87           0 :           xfree (*r_bakfname);
      88           0 :           *r_bakfname = NULL;
      89             :         }
      90             :     }
      91             : 
      92         165 :   return err;
      93             : }
      94             : 
      95             : 
      96             : static int
      97         165 : rename_tmp_file (const char *bakfname, const char *tmpfname,
      98             :                  const char *fname, int secret )
      99             : {
     100         165 :   int rc=0;
     101         165 :   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         165 :   if (!secret)
     123             :     {
     124         165 :       block = 1;
     125         165 :       rc = gnupg_rename_file (fname, bakfname, &block);
     126         165 :       if (rc)
     127           0 :         goto leave;
     128             :     }
     129             : 
     130             :   /* Then rename the file. */
     131         165 :   rc = gnupg_rename_file (tmpfname, fname, NULL);
     132         165 :   if (block)
     133             :     {
     134         165 :       gnupg_unblock_all_signals ();
     135         165 :       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         165 :   if (block)
     151           0 :     gnupg_unblock_all_signals ();
     152         165 :   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         165 : 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         165 :   int rc=0;
     166         165 :   char *bakfname = NULL;
     167         165 :   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         165 :   if (access (fname, W_OK))
     174           0 :     return gpg_error_from_syserror ();
     175             : 
     176         165 :   fp = fopen (fname, "rb");
     177         165 :   if (mode == FILECOPY_INSERT && !fp && errno == ENOENT)
     178             :     {
     179             :       /* Insert mode but file does not exist:
     180             :          Create a new keybox file. */
     181           0 :       newfp = fopen (fname, "wb");
     182           0 :       if (!newfp )
     183           0 :         return gpg_error_from_syserror ();
     184             : 
     185           0 :       rc = _keybox_write_header_blob (newfp, for_openpgp);
     186           0 :       if (rc)
     187             :         {
     188           0 :           fclose (newfp);
     189           0 :           return rc;
     190             :         }
     191             : 
     192           0 :       rc = _keybox_write_blob (blob, newfp);
     193           0 :       if (rc)
     194             :         {
     195           0 :           fclose (newfp);
     196           0 :           return rc;
     197             :         }
     198             : 
     199           0 :       if ( fclose (newfp) )
     200           0 :         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           0 :       return 0; /* Ready. */
     208             :     }
     209             : 
     210         165 :   if (!fp)
     211             :     {
     212           0 :       rc = gpg_error_from_syserror ();
     213           0 :       goto leave;
     214             :     }
     215             : 
     216             :   /* Create the new file.  On success NEWFP is initialized.  */
     217         165 :   rc = create_tmp_file (fname, &bakfname, &tmpfname, &newfp);
     218         165 :   if (rc)
     219             :     {
     220           0 :       fclose (fp);
     221           0 :       goto leave;
     222             :     }
     223             : 
     224             :   /* prepare for insert */
     225         165 :   if (mode == FILECOPY_INSERT)
     226             :     {
     227         153 :       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        2588 :       while ( (nread = fread (buffer, 1, DIM(buffer), fp)) > 0 )
     233             :         {
     234        2282 :           if (first_record && for_openpgp
     235         150 :               && buffer[4] == KEYBOX_BLOBTYPE_HEADER)
     236             :             {
     237         150 :               first_record = 0;
     238         150 :               buffer[7] |= 0x02; /* OpenPGP data may be available.  */
     239             :             }
     240             : 
     241        2282 :           if (fwrite (buffer, nread, 1, newfp) != 1)
     242             :             {
     243           0 :               rc = gpg_error_from_syserror ();
     244           0 :               fclose (fp);
     245           0 :               fclose (newfp);
     246           0 :               goto leave;
     247             :             }
     248             :         }
     249         153 :       if (ferror (fp))
     250             :         {
     251           0 :           rc = gpg_error_from_syserror ();
     252           0 :           fclose (fp);
     253           0 :           fclose (newfp);
     254           0 :           goto leave;
     255             :         }
     256             :     }
     257             : 
     258             :   /* Prepare for delete or update. */
     259         165 :   if ( mode == FILECOPY_DELETE || mode == FILECOPY_UPDATE )
     260             :     {
     261          12 :       off_t current = 0;
     262             : 
     263             :       /* Copy first part to the new file. */
     264          45 :       while ( current < start_offset )
     265             :         {
     266          21 :           nbytes = DIM(buffer);
     267          21 :           if (current + nbytes > start_offset)
     268          12 :               nbytes = start_offset - current;
     269          21 :           nread = fread (buffer, 1, nbytes, fp);
     270          21 :           if (!nread)
     271           0 :             break;
     272          21 :           current += nread;
     273             : 
     274          21 :           if (fwrite (buffer, nread, 1, newfp) != 1)
     275             :             {
     276           0 :               rc = gpg_error_from_syserror ();
     277           0 :               fclose (fp);
     278           0 :               fclose (newfp);
     279           0 :               goto leave;
     280             :             }
     281             :         }
     282          12 :       if (ferror (fp))
     283             :         {
     284           0 :           rc = gpg_error_from_syserror ();
     285           0 :           fclose (fp);
     286           0 :           fclose (newfp);
     287           0 :           goto leave;
     288             :         }
     289             : 
     290             :       /* Skip this blob. */
     291          12 :       rc = _keybox_read_blob (NULL, fp);
     292          12 :       if (rc)
     293             :         {
     294           0 :           fclose (fp);
     295           0 :           fclose (newfp);
     296           0 :           return rc;
     297             :         }
     298             :     }
     299             : 
     300             :   /* Do an insert or update. */
     301         165 :   if ( mode == FILECOPY_INSERT || mode == FILECOPY_UPDATE )
     302             :     {
     303         165 :       rc = _keybox_write_blob (blob, newfp);
     304         165 :       if (rc)
     305             :         {
     306           0 :           fclose (fp);
     307           0 :           fclose (newfp);
     308           0 :           return rc;
     309             :         }
     310             :     }
     311             : 
     312             :   /* Copy the rest of the packet for an delete or update. */
     313         165 :   if (mode == FILECOPY_DELETE || mode == FILECOPY_UPDATE)
     314             :     {
     315          38 :       while ( (nread = fread (buffer, 1, DIM(buffer), fp)) > 0 )
     316             :         {
     317          14 :           if (fwrite (buffer, nread, 1, newfp) != 1)
     318             :             {
     319           0 :               rc = gpg_error_from_syserror ();
     320           0 :               fclose (fp);
     321           0 :               fclose (newfp);
     322           0 :               goto leave;
     323             :             }
     324             :         }
     325          12 :       if (ferror (fp))
     326             :         {
     327           0 :           rc = gpg_error_from_syserror ();
     328           0 :           fclose (fp);
     329           0 :           fclose (newfp);
     330           0 :           goto leave;
     331             :         }
     332             :     }
     333             : 
     334             :   /* Close both files. */
     335         165 :   if (fclose(fp))
     336             :     {
     337           0 :       rc = gpg_error_from_syserror ();
     338           0 :       fclose (newfp);
     339           0 :       goto leave;
     340             :     }
     341         165 :   if (fclose(newfp))
     342             :     {
     343           0 :       rc = gpg_error_from_syserror ();
     344           0 :       goto leave;
     345             :     }
     346             : 
     347         165 :   rc = rename_tmp_file (bakfname, tmpfname, fname, secret);
     348             : 
     349             :  leave:
     350         165 :   xfree(bakfname);
     351         165 :   xfree(tmpfname);
     352         165 :   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         150 : 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         150 :   if (!hd)
     370           0 :     return gpg_error (GPG_ERR_INV_HANDLE);
     371         150 :   if (!hd->kb)
     372           0 :     return gpg_error (GPG_ERR_INV_HANDLE);
     373         150 :   fname = hd->kb->fname;
     374         150 :   if (!fname)
     375           0 :     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         150 :   _keybox_close_file (hd);
     382             : 
     383         150 :   err = _keybox_parse_openpgp (image, imagelen, &nparsed, &info);
     384         150 :   if (err)
     385           0 :     return err;
     386         150 :   assert (nparsed <= imagelen);
     387         150 :   err = _keybox_create_openpgp_blob (&blob, &info, image, imagelen,
     388             :                                      sigstatus, hd->ephemeral);
     389         150 :   _keybox_destroy_openpgp_info (&info);
     390         150 :   if (!err)
     391             :     {
     392         150 :       err = blob_filecopy (FILECOPY_INSERT, fname, blob, hd->secret, 1, 0);
     393         150 :       _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         150 :   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          12 : 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          12 :   if (!hd || !image || !imagelen)
     416           0 :     return gpg_error (GPG_ERR_INV_VALUE);
     417          12 :   if (!hd->found.blob)
     418           0 :     return gpg_error (GPG_ERR_NOTHING_FOUND);
     419          12 :   if (blob_get_type (hd->found.blob) != KEYBOX_BLOBTYPE_PGP)
     420           0 :     return gpg_error (GPG_ERR_WRONG_BLOB_TYPE);
     421          12 :   fname = hd->kb->fname;
     422          12 :   if (!fname)
     423           0 :     return gpg_error (GPG_ERR_INV_HANDLE);
     424             : 
     425          12 :   off = _keybox_get_blob_fileoffset (hd->found.blob);
     426          12 :   if (off == (off_t)-1)
     427           0 :     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          12 :   _keybox_close_file (hd);
     432             : 
     433             :   /* Build a new blob.  */
     434          12 :   err = _keybox_parse_openpgp (image, imagelen, &nparsed, &info);
     435          12 :   if (err)
     436           0 :     return err;
     437          12 :   assert (nparsed <= imagelen);
     438          12 :   err = _keybox_create_openpgp_blob (&blob, &info, image, imagelen,
     439             :                                      NULL, hd->ephemeral);
     440          12 :   _keybox_destroy_openpgp_info (&info);
     441             : 
     442             :   /* Update the keyblock.  */
     443          12 :   if (!err)
     444             :     {
     445          12 :       err = blob_filecopy (FILECOPY_UPDATE, fname, blob, hd->secret, 1, off);
     446          12 :       _keybox_release_blob (blob);
     447             :     }
     448          12 :   return err;
     449             : }
     450             : 
     451             : 
     452             : 
     453             : #ifdef KEYBOX_WITH_X509
     454             : int
     455           3 : 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           3 :   if (!hd)
     463           0 :     return gpg_error (GPG_ERR_INV_HANDLE);
     464           3 :   if (!hd->kb)
     465           0 :     return gpg_error (GPG_ERR_INV_HANDLE);
     466           3 :   fname = hd->kb->fname;
     467           3 :   if (!fname)
     468           0 :     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           3 :   _keybox_close_file (hd);
     474             : 
     475           3 :   rc = _keybox_create_x509_blob (&blob, cert, sha1_digest, hd->ephemeral);
     476           3 :   if (!rc)
     477             :     {
     478           3 :       rc = blob_filecopy (FILECOPY_INSERT, fname, blob, hd->secret, 0, 0);
     479           3 :       _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           3 :   return rc;
     486             : }
     487             : 
     488             : int
     489           0 : 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           0 :   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           0 : 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           0 :   if (!hd)
     518           0 :     return gpg_error (GPG_ERR_INV_VALUE);
     519           0 :   if (!hd->found.blob)
     520           0 :     return gpg_error (GPG_ERR_NOTHING_FOUND);
     521           0 :   if (!hd->kb)
     522           0 :     return gpg_error (GPG_ERR_INV_HANDLE);
     523           0 :   if (!hd->found.blob)
     524           0 :     return gpg_error (GPG_ERR_NOTHING_FOUND);
     525           0 :   fname = hd->kb->fname;
     526           0 :   if (!fname)
     527           0 :     return gpg_error (GPG_ERR_INV_HANDLE);
     528             : 
     529           0 :   off = _keybox_get_blob_fileoffset (hd->found.blob);
     530           0 :   if (off == (off_t)-1)
     531           0 :     return gpg_error (GPG_ERR_GENERAL);
     532             : 
     533           0 :   buffer = _keybox_get_blob_image (hd->found.blob, &length);
     534           0 :   ec = _keybox_get_flag_location (buffer, length, what, &flag_pos, &flag_size);
     535           0 :   if (ec)
     536           0 :     return gpg_error (ec);
     537             : 
     538           0 :   off += flag_pos;
     539             : 
     540           0 :   _keybox_close_file (hd);
     541           0 :   fp = fopen (hd->kb->fname, "r+b");
     542           0 :   if (!fp)
     543           0 :     return gpg_error_from_syserror ();
     544             : 
     545           0 :   ec = 0;
     546           0 :   if (fseeko (fp, off, SEEK_SET))
     547           0 :     ec = gpg_err_code_from_syserror ();
     548             :   else
     549             :     {
     550             :       unsigned char tmp[4];
     551             : 
     552           0 :       tmp[0] = value >> 24;
     553           0 :       tmp[1] = value >> 16;
     554           0 :       tmp[2] = value >>  8;
     555           0 :       tmp[3] = value;
     556             : 
     557           0 :       switch (flag_size)
     558             :         {
     559             :         case 1:
     560             :         case 2:
     561             :         case 4:
     562           0 :           if (fwrite (tmp+4-flag_size, flag_size, 1, fp) != 1)
     563           0 :             ec = gpg_err_code_from_syserror ();
     564           0 :           break;
     565             :         default:
     566           0 :           ec = GPG_ERR_BUG;
     567           0 :           break;
     568             :         }
     569             :     }
     570             : 
     571           0 :   if (fclose (fp))
     572             :     {
     573           0 :       if (!ec)
     574           0 :         ec = gpg_err_code_from_syserror ();
     575             :     }
     576             : 
     577           0 :   return gpg_error (ec);
     578             : }
     579             : 
     580             : 
     581             : 
     582             : int
     583          87 : keybox_delete (KEYBOX_HANDLE hd)
     584             : {
     585             :   off_t off;
     586             :   const char *fname;
     587             :   FILE *fp;
     588             :   int rc;
     589             : 
     590          87 :   if (!hd)
     591           0 :     return gpg_error (GPG_ERR_INV_VALUE);
     592          87 :   if (!hd->found.blob)
     593           0 :     return gpg_error (GPG_ERR_NOTHING_FOUND);
     594          87 :   if (!hd->kb)
     595           0 :     return gpg_error (GPG_ERR_INV_HANDLE);
     596          87 :   fname = hd->kb->fname;
     597          87 :   if (!fname)
     598           0 :     return gpg_error (GPG_ERR_INV_HANDLE);
     599             : 
     600          87 :   off = _keybox_get_blob_fileoffset (hd->found.blob);
     601          87 :   if (off == (off_t)-1)
     602           0 :     return gpg_error (GPG_ERR_GENERAL);
     603          87 :   off += 4;
     604             : 
     605          87 :   _keybox_close_file (hd);
     606          87 :   fp = fopen (hd->kb->fname, "r+b");
     607          87 :   if (!fp)
     608           0 :     return gpg_error_from_syserror ();
     609             : 
     610          87 :   if (fseeko (fp, off, SEEK_SET))
     611           0 :     rc = gpg_error_from_syserror ();
     612          87 :   else if (putc (0, fp) == EOF)
     613           0 :     rc = gpg_error_from_syserror ();
     614             :   else
     615          87 :     rc = 0;
     616             : 
     617          87 :   if (fclose (fp))
     618             :     {
     619           0 :       if (!rc)
     620           0 :         rc = gpg_error_from_syserror ();
     621             :     }
     622             : 
     623          87 :   return rc;
     624             : }
     625             : 
     626             : 
     627             : /* Compress the keybox file.  This should be run with the file
     628             :    locked. */
     629             : int
     630           3 : keybox_compress (KEYBOX_HANDLE hd)
     631             : {
     632             :   int read_rc, rc;
     633             :   const char *fname;
     634             :   FILE *fp, *newfp;
     635           3 :   char *bakfname = NULL;
     636           3 :   char *tmpfname = NULL;
     637             :   int first_blob;
     638           3 :   KEYBOXBLOB blob = NULL;
     639             :   u32 cut_time;
     640           3 :   int any_changes = 0;
     641             :   int skipped_deleted;
     642             : 
     643           3 :   if (!hd)
     644           0 :     return gpg_error (GPG_ERR_INV_HANDLE);
     645           3 :   if (!hd->kb)
     646           0 :     return gpg_error (GPG_ERR_INV_HANDLE);
     647           3 :   if (hd->secret)
     648           0 :     return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
     649           3 :   fname = hd->kb->fname;
     650           3 :   if (!fname)
     651           0 :     return gpg_error (GPG_ERR_INV_HANDLE);
     652             : 
     653           3 :   _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           3 :   if (access (fname, W_OK))
     658           0 :     return gpg_error_from_syserror ();
     659             : 
     660           3 :   fp = fopen (fname, "rb");
     661           3 :   if (!fp && errno == ENOENT)
     662           0 :     return 0; /* Ready. File has been deleted right after the access above. */
     663           3 :   if (!fp)
     664             :     {
     665           0 :       rc = gpg_error_from_syserror ();
     666           0 :       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           3 :   if ( !_keybox_read_blob (&blob, fp) )
     672             :     {
     673             :       const unsigned char *buffer;
     674             :       size_t length;
     675             : 
     676           3 :       buffer = _keybox_get_blob_image (blob, &length);
     677           3 :       if (length > 4 && buffer[4] == KEYBOX_BLOBTYPE_HEADER)
     678             :         {
     679           3 :           u32 last_maint = buf32_to_u32 (buffer+20);
     680             : 
     681           3 :           if ( (last_maint + 3*3600) > time (NULL) )
     682             :             {
     683           3 :               fclose (fp);
     684           3 :               _keybox_release_blob (blob);
     685           3 :               return 0; /* Compress run not yet needed. */
     686             :             }
     687             :         }
     688           0 :       _keybox_release_blob (blob);
     689           0 :       fseek (fp, 0, SEEK_SET);
     690           0 :       clearerr (fp);
     691             :     }
     692             : 
     693             :   /* Create the new file. */
     694           0 :   rc = create_tmp_file (fname, &bakfname, &tmpfname, &newfp);
     695           0 :   if (rc)
     696             :     {
     697           0 :       fclose (fp);
     698           0 :       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           0 :   cut_time = time(NULL) - 86400;
     707           0 :   first_blob = 1;
     708           0 :   skipped_deleted = 0;
     709           0 :   for (rc=0; !(read_rc = _keybox_read_blob2 (&blob, fp, &skipped_deleted));
     710           0 :        _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           0 :       if (skipped_deleted)
     718           0 :         any_changes = 1;
     719           0 :       buffer = _keybox_get_blob_image (blob, &length);
     720           0 :       if (first_blob)
     721             :         {
     722           0 :           first_blob = 0;
     723           0 :           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           0 :               _keybox_update_header_blob (blob, hd->for_openpgp);
     729           0 :               rc = _keybox_write_blob (blob, newfp);
     730           0 :               if (rc)
     731           0 :                 break;
     732           0 :               continue;
     733             :             }
     734             : 
     735             :           /* The header blob is missing.  Insert it.  */
     736           0 :           rc = _keybox_write_header_blob (newfp, hd->for_openpgp);
     737           0 :           if (rc)
     738           0 :             break;
     739           0 :           any_changes = 1;
     740             :         }
     741           0 :       else if (length > 4 && buffer[4] == KEYBOX_BLOBTYPE_HEADER)
     742             :         {
     743             :           /* Oops: There is another header record - remove it. */
     744           0 :           any_changes = 1;
     745           0 :           continue;
     746             :         }
     747             : 
     748           0 :       if (_keybox_get_flag_location (buffer, length,
     749             :                                      KEYBOX_FLAG_BLOB, &pos, &size)
     750           0 :           || size != 2)
     751             :         {
     752           0 :           rc = gpg_error (GPG_ERR_BUG);
     753           0 :           break;
     754             :         }
     755           0 :       blobflags = buf16_to_uint (buffer+pos);
     756           0 :       if ((blobflags & KEYBOX_FLAG_BLOB_EPHEMERAL))
     757             :         {
     758             :           /* This is an ephemeral blob. */
     759           0 :           if (_keybox_get_flag_location (buffer, length,
     760             :                                          KEYBOX_FLAG_CREATED_AT, &pos, &size)
     761           0 :               || size != 4)
     762           0 :             created_at = 0; /* oops. */
     763             :           else
     764           0 :             created_at = buf32_to_u32 (buffer+pos);
     765             : 
     766           0 :           if (created_at && created_at < cut_time)
     767             :             {
     768           0 :               any_changes = 1;
     769           0 :               continue; /* Skip this blob. */
     770             :             }
     771             :         }
     772             : 
     773           0 :       rc = _keybox_write_blob (blob, newfp);
     774           0 :       if (rc)
     775           0 :         break;
     776             :     }
     777           0 :   if (skipped_deleted)
     778           0 :     any_changes = 1;
     779           0 :   _keybox_release_blob (blob); blob = NULL;
     780           0 :   if (!rc && read_rc == -1)
     781           0 :     rc = 0;
     782           0 :   else if (!rc)
     783           0 :     rc = read_rc;
     784             : 
     785             :   /* Close both files. */
     786           0 :   if (fclose(fp) && !rc)
     787           0 :     rc = gpg_error_from_syserror ();
     788           0 :   if (fclose(newfp) && !rc)
     789           0 :     rc = gpg_error_from_syserror ();
     790             : 
     791             :   /* Rename or remove the temporary file. */
     792           0 :   if (rc || !any_changes)
     793           0 :     gnupg_remove (tmpfname);
     794             :   else
     795           0 :     rc = rename_tmp_file (bakfname, tmpfname, fname, hd->secret);
     796             : 
     797           0 :   xfree(bakfname);
     798           0 :   xfree(tmpfname);
     799           0 :   return rc;
     800             : }

Generated by: LCOV version 1.11