LCOV - code coverage report
Current view: top level - kbx - keybox-init.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 95 129 73.6 %
Date: 2016-11-29 15:00:56 Functions: 11 12 91.7 %

          Line data    Source code
       1             : /* keybox-init.c - Initialization of the library
       2             :  *      Copyright (C) 2001 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 <unistd.h>
      25             : #include <assert.h>
      26             : 
      27             : #include "keybox-defs.h"
      28             : #include "../common/mischelp.h"
      29             : 
      30             : static KB_NAME kb_names;
      31             : 
      32             : 
      33             : /* Register a filename for plain keybox files.  Returns 0 on success,
      34             :  * GPG_ERR_EEXIST if it has already been registered, or another error
      35             :  * code.  On success or with error code GPG_ERR_EEXIST a token usable
      36             :  * to access the keybox handle is stored at R_TOKEN, NULL is stored
      37             :  * for all other errors.  */
      38             : gpg_error_t
      39        1118 : keybox_register_file (const char *fname, int secret, void **r_token)
      40             : {
      41             :   KB_NAME kr;
      42             : 
      43        1118 :   *r_token = NULL;
      44             : 
      45        1118 :   for (kr=kb_names; kr; kr = kr->next)
      46             :     {
      47           0 :       if (same_file_p (kr->fname, fname) )
      48             :         {
      49           0 :           *r_token = kr;
      50           0 :           return gpg_error (GPG_ERR_EEXIST); /* Already registered. */
      51             :         }
      52             :     }
      53             : 
      54        1118 :   kr = xtrymalloc (sizeof *kr + strlen (fname));
      55        1118 :   if (!kr)
      56           0 :     return gpg_error_from_syserror ();
      57        1118 :   strcpy (kr->fname, fname);
      58        1118 :   kr->secret = !!secret;
      59             : 
      60        1118 :   kr->handle_table = NULL;
      61        1118 :   kr->handle_table_size = 0;
      62             : 
      63        1118 :   kr->lockhd = NULL;
      64        1118 :   kr->is_locked = 0;
      65        1118 :   kr->did_full_scan = 0;
      66             :   /* keep a list of all issued pointers */
      67        1118 :   kr->next = kb_names;
      68        1118 :   kb_names = kr;
      69             : 
      70             :   /* create the offset table the first time a function here is used */
      71             : /*      if (!kb_offtbl) */
      72             : /*        kb_offtbl = new_offset_hash_table (); */
      73             : 
      74        1118 :   *r_token = kr;
      75        1118 :   return 0;
      76             : }
      77             : 
      78             : int
      79         651 : keybox_is_writable (void *token)
      80             : {
      81         651 :   KB_NAME r = token;
      82             : 
      83         651 :   return r? !access (r->fname, W_OK) : 0;
      84             : }
      85             : 
      86             : 
      87             : 
      88             : static KEYBOX_HANDLE
      89        3458 : do_keybox_new (KB_NAME resource, int secret, int for_openpgp)
      90             : {
      91             :   KEYBOX_HANDLE hd;
      92             :   int idx;
      93             : 
      94        3458 :   assert (resource && !resource->secret == !secret);
      95        3458 :   hd = xtrycalloc (1, sizeof *hd);
      96        3458 :   if (hd)
      97             :     {
      98        3458 :       hd->kb = resource;
      99        3458 :       hd->secret = !!secret;
     100        3458 :       hd->for_openpgp = for_openpgp;
     101        3458 :       if (!resource->handle_table)
     102             :         {
     103         996 :           resource->handle_table_size = 3;
     104         996 :           resource->handle_table = xtrycalloc (resource->handle_table_size,
     105             :                                                sizeof *resource->handle_table);
     106         996 :           if (!resource->handle_table)
     107             :             {
     108           0 :               resource->handle_table_size = 0;
     109           0 :               xfree (hd);
     110           0 :               return NULL;
     111             :             }
     112             :         }
     113        3849 :       for (idx=0; idx < resource->handle_table_size; idx++)
     114        3849 :         if (!resource->handle_table[idx])
     115             :           {
     116        3458 :             resource->handle_table[idx] = hd;
     117        3458 :             break;
     118             :           }
     119        3458 :       if (!(idx < resource->handle_table_size))
     120             :         {
     121             :           KEYBOX_HANDLE *tmptbl;
     122             :           size_t newsize;
     123             : 
     124           0 :           newsize = resource->handle_table_size + 5;
     125           0 :           tmptbl = xtryrealloc (resource->handle_table,
     126             :                                 newsize * sizeof (*tmptbl));
     127           0 :           if (!tmptbl)
     128             :             {
     129           0 :               xfree (hd);
     130           0 :               return NULL;
     131             :             }
     132           0 :           resource->handle_table = tmptbl;
     133           0 :           resource->handle_table_size = newsize;
     134           0 :           resource->handle_table[idx] = hd;
     135           0 :           for (idx++; idx < resource->handle_table_size; idx++)
     136           0 :             resource->handle_table[idx] = NULL;
     137             :         }
     138             :     }
     139        3458 :   return hd;
     140             : }
     141             : 
     142             : 
     143             : /* Create a new handle for the resource associated with TOKEN.  SECRET
     144             :    is just a cross-check.  This is the OpenPGP version.  The returned
     145             :    handle must be released using keybox_release.  */
     146             : KEYBOX_HANDLE
     147        3446 : keybox_new_openpgp (void *token, int secret)
     148             : {
     149        3446 :   KB_NAME resource = token;
     150             : 
     151        3446 :   return do_keybox_new (resource, secret, 1);
     152             : }
     153             : 
     154             : /* Create a new handle for the resource associated with TOKEN.  SECRET
     155             :    is just a cross-check.  This is the X.509 version.  The returned
     156             :    handle must be released using keybox_release.  */
     157             : KEYBOX_HANDLE
     158          12 : keybox_new_x509 (void *token, int secret)
     159             : {
     160          12 :   KB_NAME resource = token;
     161             : 
     162          12 :   return do_keybox_new (resource, secret, 0);
     163             : }
     164             : 
     165             : 
     166             : void
     167        3458 : keybox_release (KEYBOX_HANDLE hd)
     168             : {
     169        3458 :   if (!hd)
     170        3458 :     return;
     171        3458 :   if (hd->kb->handle_table)
     172             :     {
     173             :       int idx;
     174       13832 :       for (idx=0; idx < hd->kb->handle_table_size; idx++)
     175       10374 :         if (hd->kb->handle_table[idx] == hd)
     176        3458 :           hd->kb->handle_table[idx] = NULL;
     177             :     }
     178        3458 :   _keybox_release_blob (hd->found.blob);
     179        3458 :   _keybox_release_blob (hd->saved_found.blob);
     180        3458 :   if (hd->fp)
     181             :     {
     182        3195 :       fclose (hd->fp);
     183        3195 :       hd->fp = NULL;
     184             :     }
     185        3458 :   xfree (hd->word_match.name);
     186        3458 :   xfree (hd->word_match.pattern);
     187        3458 :   xfree (hd);
     188             : }
     189             : 
     190             : 
     191             : /* Save the current found state in HD for later retrieval by
     192             :    keybox_restore_found_state.  Only one state may be saved.  */
     193             : void
     194           2 : keybox_push_found_state (KEYBOX_HANDLE hd)
     195             : {
     196           2 :   if (hd->saved_found.blob)
     197             :     {
     198           0 :       _keybox_release_blob (hd->saved_found.blob);
     199           0 :       hd->saved_found.blob = NULL;
     200             :     }
     201           2 :   hd->saved_found = hd->found;
     202           2 :   hd->found.blob = NULL;
     203           2 : }
     204             : 
     205             : 
     206             : /* Restore the saved found state in HD.  */
     207             : void
     208           2 : keybox_pop_found_state (KEYBOX_HANDLE hd)
     209             : {
     210           2 :   if (hd->found.blob)
     211             :     {
     212           0 :       _keybox_release_blob (hd->found.blob);
     213           0 :       hd->found.blob = NULL;
     214             :     }
     215           2 :   hd->found = hd->saved_found;
     216           2 :   hd->saved_found.blob = NULL;
     217           2 : }
     218             : 
     219             : 
     220             : const char *
     221           0 : keybox_get_resource_name (KEYBOX_HANDLE hd)
     222             : {
     223           0 :   if (!hd || !hd->kb)
     224           0 :     return NULL;
     225           0 :   return hd->kb->fname;
     226             : }
     227             : 
     228             : int
     229           6 : keybox_set_ephemeral (KEYBOX_HANDLE hd, int yes)
     230             : {
     231           6 :   if (!hd)
     232           0 :     return gpg_error (GPG_ERR_INV_HANDLE);
     233           6 :   hd->ephemeral = yes;
     234           6 :   return 0;
     235             : }
     236             : 
     237             : 
     238             : /* Close the file of the resource identified by HD.  For consistent
     239             :    results this function closes the files of all handles pointing to
     240             :    the resource identified by HD.  */
     241             : void
     242         255 : _keybox_close_file (KEYBOX_HANDLE hd)
     243             : {
     244             :   int idx;
     245             :   KEYBOX_HANDLE roverhd;
     246             : 
     247         255 :   if (!hd || !hd->kb || !hd->kb->handle_table)
     248         255 :     return;
     249             : 
     250        1020 :   for (idx=0; idx < hd->kb->handle_table_size; idx++)
     251         765 :     if ((roverhd = hd->kb->handle_table[idx]))
     252             :       {
     253         255 :         if (roverhd->fp)
     254             :           {
     255          99 :             fclose (roverhd->fp);
     256          99 :             roverhd->fp = NULL;
     257             :           }
     258             :       }
     259         255 :   assert (!hd->fp);
     260             : }
     261             : 
     262             : 
     263             : /*
     264             :  * Lock the keybox at handle HD, or unlock if YES is false.
     265             :  */
     266             : gpg_error_t
     267         498 : keybox_lock (KEYBOX_HANDLE hd, int yes)
     268             : {
     269         498 :   gpg_error_t err = 0;
     270         498 :   KB_NAME kb = hd->kb;
     271             : 
     272         498 :   if (!keybox_is_writable (kb))
     273           0 :     return 0;
     274             : 
     275             :   /* Make sure the lock handle has been created.  */
     276         498 :   if (!kb->lockhd)
     277             :     {
     278         109 :       kb->lockhd = dotlock_create (kb->fname, 0);
     279         109 :       if (!kb->lockhd)
     280             :         {
     281           0 :           err = gpg_error_from_syserror ();
     282           0 :           log_info ("can't allocate lock for '%s'\n", kb->fname );
     283           0 :           return err;
     284             :         }
     285             :     }
     286             : 
     287         498 :   if (yes) /* Take the lock.  */
     288             :     {
     289         249 :       if (!kb->is_locked)
     290             :         {
     291             : #ifdef HAVE_W32_SYSTEM
     292             :             /* Under Windows we need to close the file before we try
     293             :              * to lock it.  This is because another process might have
     294             :              * taken the lock and is using keybox_file_rename to
     295             :              * rename the base file.  How if our dotlock_take below is
     296             :              * waiting for the lock but we have the base file still
     297             :              * open, keybox_file_rename will never succeed as we are
     298             :              * in a deadlock.  */
     299             :           if (hd->fp)
     300             :             {
     301             :               fclose (hd->fp);
     302             :               hd->fp = NULL;
     303             :             }
     304             : #endif /*HAVE_W32_SYSTEM*/
     305         249 :           if (dotlock_take (kb->lockhd, -1))
     306             :             {
     307           0 :               err = gpg_error_from_syserror ();
     308           0 :               log_info ("can't lock '%s'\n", kb->fname );
     309             :             }
     310             :           else
     311         249 :             kb->is_locked = 1;
     312             :         }
     313             :     }
     314             :   else /* Release the lock.  */
     315             :     {
     316         249 :       if (kb->is_locked)
     317             :         {
     318         249 :           if (dotlock_release (kb->lockhd))
     319             :             {
     320           0 :               err = gpg_error_from_syserror ();
     321           0 :               log_info ("can't unlock '%s'\n", kb->fname );
     322             :             }
     323             :           else
     324         249 :             kb->is_locked = 0;
     325             :         }
     326             :    }
     327             : 
     328         498 :   return err;
     329             : }

Generated by: LCOV version 1.11