speedo: Improve building of the w32 installer.
[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 "../common/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   _keybox_release_blob (hd->saved_found.blob);
152   if (hd->fp)
153     {
154       fclose (hd->fp);
155       hd->fp = NULL;
156     }
157   xfree (hd->word_match.name);
158   xfree (hd->word_match.pattern);
159   xfree (hd);
160 }
161
162
163 /* Save the current found state in HD for later retrieval by
164    keybox_restore_found_state.  Only one state may be saved.  */
165 void
166 keybox_push_found_state (KEYBOX_HANDLE hd)
167 {
168   if (hd->saved_found.blob)
169     {
170       _keybox_release_blob (hd->saved_found.blob);
171       hd->saved_found.blob = NULL;
172     }
173   hd->saved_found = hd->found;
174   hd->found.blob = NULL;
175 }
176
177
178 /* Restore the saved found state in HD.  */
179 void
180 keybox_pop_found_state (KEYBOX_HANDLE hd)
181 {
182   if (hd->found.blob)
183     {
184       _keybox_release_blob (hd->found.blob);
185       hd->found.blob = NULL;
186     }
187   hd->found = hd->saved_found;
188   hd->saved_found.blob = NULL;
189 }
190
191
192 const char *
193 keybox_get_resource_name (KEYBOX_HANDLE hd)
194 {
195   if (!hd || !hd->kb)
196     return NULL;
197   return hd->kb->fname;
198 }
199
200 int
201 keybox_set_ephemeral (KEYBOX_HANDLE hd, int yes)
202 {
203   if (!hd)
204     return gpg_error (GPG_ERR_INV_HANDLE);
205   hd->ephemeral = yes;
206   return 0;
207 }
208
209
210 /* Close the file of the resource identified by HD.  For consistent
211    results this fucntion closes the files of all handles pointing to
212    the resource identified by HD.  */
213 void
214 _keybox_close_file (KEYBOX_HANDLE hd)
215 {
216   int idx;
217   KEYBOX_HANDLE roverhd;
218
219   if (!hd || !hd->kb || !hd->kb->handle_table)
220     return;
221
222   for (idx=0; idx < hd->kb->handle_table_size; idx++)
223     if ((roverhd = hd->kb->handle_table[idx]))
224       {
225         if (roverhd->fp)
226           {
227             fclose (roverhd->fp);
228             roverhd->fp = NULL;
229           }
230       }
231   assert (!hd->fp);
232 }
233
234
235 /*
236  * Lock the keybox at handle HD, or unlock if YES is false.  Note that
237  * we currently ignore the handle and lock all registered keyboxes.
238  */
239 int
240 keybox_lock (KEYBOX_HANDLE hd, int yes)
241 {
242   /* FIXME: We need to implement it before we can use it with gpg.
243      gpgsm does the locking in its local keydb.c driver; this should
244      be changed as well.  */
245
246   (void)hd;
247   (void)yes;
248   return 0;
249 }