e4138647e763d89399f37c6d280da5d0468e872d
[gnupg.git] / kbx / keybox-init.c
1 /* keybox-init.c - Initalization 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 <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 <unistd.h>
25 #include <assert.h>
26
27 #include "../jnlib/mischelp.h"
28 #include "keybox-defs.h"
29
30 static KB_NAME kb_names;
31
32
33 /* Register a filename for plain keybox files.  Returns a pointer to
34    be used to create a handles and so on.  Returns NULL to indicate
35    that FNAME has already been registered.  */
36 void *
37 keybox_register_file (const char *fname, int secret)
38 {
39   KB_NAME kr;
40
41   for (kr=kb_names; kr; kr = kr->next)
42     {
43       if (same_file_p (kr->fname, fname) )
44         return NULL; /* Already registered. */
45     }
46
47   kr = xtrymalloc (sizeof *kr + strlen (fname));
48   if (!kr)
49     return NULL;
50   strcpy (kr->fname, fname);
51   kr->secret = !!secret;
52
53   kr->handle_table = NULL;
54   kr->handle_table_size = 0;
55
56   /* kr->lockhd = NULL;*/
57   kr->is_locked = 0;
58   kr->did_full_scan = 0;
59   /* keep a list of all issued pointers */
60   kr->next = kb_names;
61   kb_names = kr;
62   
63   /* create the offset table the first time a function here is used */
64 /*      if (!kb_offtbl) */
65 /*        kb_offtbl = new_offset_hash_table (); */
66
67   return kr;
68 }
69
70 int
71 keybox_is_writable (void *token)
72 {
73   KB_NAME r = token;
74
75   return r? !access (r->fname, W_OK) : 0;
76 }
77
78     
79
80 /* Create a new handle for the resource associated with TOKEN.  SECRET
81    is just a cross-check.
82    
83    The returned handle must be released using keybox_release (). */
84 KEYBOX_HANDLE
85 keybox_new (void *token, int secret)
86 {
87   KEYBOX_HANDLE hd;
88   KB_NAME resource = token;
89   int idx;
90
91   assert (resource && !resource->secret == !secret);
92   hd = xtrycalloc (1, sizeof *hd);
93   if (hd)
94     {
95       hd->kb = resource;
96       hd->secret = !!secret;
97       if (!resource->handle_table)
98         {
99           resource->handle_table_size = 3;
100           resource->handle_table = xtrycalloc (resource->handle_table_size,
101                                                sizeof *resource->handle_table);
102           if (!resource->handle_table)
103             {
104               resource->handle_table_size = 0;
105               xfree (hd);
106               return NULL;
107             }
108         }
109       for (idx=0; idx < resource->handle_table_size; idx++)
110         if (!resource->handle_table[idx])
111           {
112             resource->handle_table[idx] = hd;
113             break;
114           }
115       if (!(idx < resource->handle_table_size))
116         {
117           KEYBOX_HANDLE *tmptbl;
118           size_t newsize;
119
120           newsize = resource->handle_table_size + 5;
121           tmptbl = xtryrealloc (resource->handle_table, 
122                                 newsize * sizeof (*tmptbl));
123           if (!tmptbl)
124             {
125               xfree (hd);
126               return NULL;
127             }
128           resource->handle_table = tmptbl;
129           resource->handle_table_size = newsize;
130           resource->handle_table[idx] = hd;
131           for (idx++; idx < resource->handle_table_size; idx++)
132             resource->handle_table[idx] = NULL;
133         }
134     }
135   return hd;
136 }
137
138 void 
139 keybox_release (KEYBOX_HANDLE hd)
140 {
141   if (!hd)
142     return;
143   if (hd->kb->handle_table)
144     {
145       int idx;
146       for (idx=0; idx < hd->kb->handle_table_size; idx++)
147         if (hd->kb->handle_table[idx] == hd)
148           hd->kb->handle_table[idx] = NULL;
149     }
150   _keybox_release_blob (hd->found.blob);
151   if (hd->fp)
152     {
153       fclose (hd->fp);
154       hd->fp = NULL;
155     }
156   xfree (hd->word_match.name);
157   xfree (hd->word_match.pattern);
158   xfree (hd);
159 }
160
161
162 const char *
163 keybox_get_resource_name (KEYBOX_HANDLE hd)
164 {
165   if (!hd || !hd->kb)
166     return NULL;
167   return hd->kb->fname;
168 }
169
170 int
171 keybox_set_ephemeral (KEYBOX_HANDLE hd, int yes)
172 {
173   if (!hd)
174     return gpg_error (GPG_ERR_INV_HANDLE); 
175   hd->ephemeral = yes;
176   return 0;
177 }
178
179
180 /* Close the file of the resource identified by HD.  For consistent
181    results this fucntion closes the files of all handles pointing to
182    the resource identified by HD.  */
183 void 
184 _keybox_close_file (KEYBOX_HANDLE hd)
185 {
186   int idx;
187   KEYBOX_HANDLE roverhd;
188
189   if (!hd || !hd->kb || !hd->kb->handle_table)
190     return;
191
192   for (idx=0; idx < hd->kb->handle_table_size; idx++)
193     if ((roverhd = hd->kb->handle_table[idx]))
194       {
195         if (roverhd->fp)
196           {
197             fclose (roverhd->fp);
198             roverhd->fp = NULL;
199           }
200       }
201   assert (!hd->fp);
202 }