s4:heimdal: import lorikeet-heimdal-201003262338 (commit f4e0dc17709829235f057e0e100d...
[sfrench/samba-autobuild/.git] / source4 / heimdal / lib / hdb / ndbm.c
1 /*
2  * Copyright (c) 1997 - 2001 Kungliga Tekniska Högskolan
3  * (Royal Institute of Technology, Stockholm, Sweden).
4  * All rights reserved.
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions
8  * are met:
9  *
10  * 1. Redistributions of source code must retain the above copyright
11  *    notice, this list of conditions and the following disclaimer.
12  *
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in the
15  *    documentation and/or other materials provided with the distribution.
16  *
17  * 3. Neither the name of the Institute nor the names of its contributors
18  *    may be used to endorse or promote products derived from this software
19  *    without specific prior written permission.
20  *
21  * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31  * SUCH DAMAGE.
32  */
33
34 #include "hdb_locl.h"
35
36 #if HAVE_NDBM
37
38 #if defined(HAVE_GDBM_NDBM_H)
39 #include <gdbm/ndbm.h>
40 #elif defined(HAVE_NDBM_H)
41 #include <ndbm.h>
42 #elif defined(HAVE_DBM_H)
43 #include <dbm.h>
44 #endif
45
46 struct ndbm_db {
47     DBM *db;
48     int lock_fd;
49 };
50
51 static krb5_error_code
52 NDBM_destroy(krb5_context context, HDB *db)
53 {
54     hdb_clear_master_key (context, db);
55     free(db->hdb_name);
56     free(db);
57     return 0;
58 }
59
60 static krb5_error_code
61 NDBM_lock(krb5_context context, HDB *db, int operation)
62 {
63     struct ndbm_db *d = db->hdb_db;
64     return hdb_lock(d->lock_fd, operation);
65 }
66
67 static krb5_error_code
68 NDBM_unlock(krb5_context context, HDB *db)
69 {
70     struct ndbm_db *d = db->hdb_db;
71     return hdb_unlock(d->lock_fd);
72 }
73
74 static krb5_error_code
75 NDBM_seq(krb5_context context, HDB *db,
76          unsigned flags, hdb_entry_ex *entry, int first)
77
78 {
79     struct ndbm_db *d = (struct ndbm_db *)db->hdb_db;
80     datum key, value;
81     krb5_data key_data, data;
82     krb5_error_code ret = 0;
83
84     if(first)
85         key = dbm_firstkey(d->db);
86     else
87         key = dbm_nextkey(d->db);
88     if(key.dptr == NULL)
89         return HDB_ERR_NOENTRY;
90     key_data.data = key.dptr;
91     key_data.length = key.dsize;
92     ret = db->hdb_lock(context, db, HDB_RLOCK);
93     if(ret) return ret;
94     value = dbm_fetch(d->db, key);
95     db->hdb_unlock(context, db);
96     data.data = value.dptr;
97     data.length = value.dsize;
98     memset(entry, 0, sizeof(*entry));
99     if(hdb_value2entry(context, &data, &entry->entry))
100         return NDBM_seq(context, db, flags, entry, 0);
101     if (db->hdb_master_key_set && (flags & HDB_F_DECRYPT)) {
102         ret = hdb_unseal_keys (context, db, &entry->entry);
103         if (ret)
104             hdb_free_entry (context, entry);
105     }
106     if (ret == 0 && entry->entry.principal == NULL) {
107         entry->entry.principal = malloc (sizeof(*entry->entry.principal));
108         if (entry->entry.principal == NULL) {
109             hdb_free_entry (context, entry);
110             ret = ENOMEM;
111             krb5_set_error_message(context, ret, "malloc: out of memory");
112         } else {
113             hdb_key2principal (context, &key_data, entry->entry.principal);
114         }
115     }
116     return ret;
117 }
118
119
120 static krb5_error_code
121 NDBM_firstkey(krb5_context context, HDB *db,unsigned flags,hdb_entry_ex *entry)
122 {
123     return NDBM_seq(context, db, flags, entry, 1);
124 }
125
126
127 static krb5_error_code
128 NDBM_nextkey(krb5_context context, HDB *db, unsigned flags,hdb_entry_ex *entry)
129 {
130     return NDBM_seq(context, db, flags, entry, 0);
131 }
132
133 static krb5_error_code
134 open_lock_file(krb5_context context, const char *db_name, int *fd)
135 {
136     char *lock_file;
137
138     /* lock old and new databases */
139     asprintf(&lock_file, "%s.lock", db_name);
140     if(lock_file == NULL) {
141         krb5_set_error_message(context, ENOMEM, "malloc: out of memory");
142         return ENOMEM;
143     }
144
145     *fd = open(lock_file, O_RDWR | O_CREAT, 0600);
146     free(lock_file);
147     if(*fd < 0) {
148         int ret = errno;
149         krb5_set_error_message(context, ret, "open(%s): %s", lock_file,
150                                strerror(ret));
151         return ret;
152     }
153     return 0;
154 }
155
156
157 static krb5_error_code
158 NDBM_rename(krb5_context context, HDB *db, const char *new_name)
159 {
160     int ret;
161     char *old_dir, *old_pag, *new_dir, *new_pag;
162     int old_lock_fd, new_lock_fd;
163
164     /* lock old and new databases */
165     ret = open_lock_file(context, db->hdb_name, &old_lock_fd);
166     if (ret)
167         return ret;
168
169     ret = hdb_lock(old_lock_fd, HDB_WLOCK);
170     if(ret) {
171         close(old_lock_fd);
172         return ret;
173     }
174
175     ret = open_lock_file(context, new_name, &new_lock_fd);
176     if (ret) {
177         hdb_unlock(old_lock_fd);
178         close(old_lock_fd);
179         return ret;
180     }
181
182     ret = hdb_lock(new_lock_fd, HDB_WLOCK);
183     if(ret) {
184         hdb_unlock(old_lock_fd);
185         close(old_lock_fd);
186         close(new_lock_fd);
187         return ret;
188     }
189
190     asprintf(&old_dir, "%s.dir", db->hdb_name);
191     asprintf(&old_pag, "%s.pag", db->hdb_name);
192     asprintf(&new_dir, "%s.dir", new_name);
193     asprintf(&new_pag, "%s.pag", new_name);
194
195     ret = rename(old_dir, new_dir) || rename(old_pag, new_pag);
196     if (ret) {
197         ret = errno;
198         if (ret == 0)
199             ret = EPERM;
200         krb5_set_error_message(context, ret, "rename: %s", strerror(ret));
201     }
202
203     free(old_dir);
204     free(old_pag);
205     free(new_dir);
206     free(new_pag);
207
208     hdb_unlock(new_lock_fd);
209     hdb_unlock(old_lock_fd);
210     close(new_lock_fd);
211     close(old_lock_fd);
212
213     if(ret)
214         return ret;
215
216     free(db->hdb_name);
217     db->hdb_name = strdup(new_name);
218     return 0;
219 }
220
221 static krb5_error_code
222 NDBM__get(krb5_context context, HDB *db, krb5_data key, krb5_data *reply)
223 {
224     struct ndbm_db *d = (struct ndbm_db *)db->hdb_db;
225     datum k, v;
226     int code;
227
228     k.dptr  = key.data;
229     k.dsize = key.length;
230     code = db->hdb_lock(context, db, HDB_RLOCK);
231     if(code)
232         return code;
233     v = dbm_fetch(d->db, k);
234     db->hdb_unlock(context, db);
235     if(v.dptr == NULL)
236         return HDB_ERR_NOENTRY;
237
238     krb5_data_copy(reply, v.dptr, v.dsize);
239     return 0;
240 }
241
242 static krb5_error_code
243 NDBM__put(krb5_context context, HDB *db, int replace,
244         krb5_data key, krb5_data value)
245 {
246     struct ndbm_db *d = (struct ndbm_db *)db->hdb_db;
247     datum k, v;
248     int code;
249
250     k.dptr  = key.data;
251     k.dsize = key.length;
252     v.dptr  = value.data;
253     v.dsize = value.length;
254
255     code = db->hdb_lock(context, db, HDB_WLOCK);
256     if(code)
257         return code;
258     code = dbm_store(d->db, k, v, replace ? DBM_REPLACE : DBM_INSERT);
259     db->hdb_unlock(context, db);
260     if(code == 1)
261         return HDB_ERR_EXISTS;
262     if (code < 0)
263         return code;
264     return 0;
265 }
266
267 static krb5_error_code
268 NDBM__del(krb5_context context, HDB *db, krb5_data key)
269 {
270     struct ndbm_db *d = (struct ndbm_db *)db->hdb_db;
271     datum k;
272     int code;
273     krb5_error_code ret;
274
275     k.dptr = key.data;
276     k.dsize = key.length;
277     ret = db->hdb_lock(context, db, HDB_WLOCK);
278     if(ret) return ret;
279     code = dbm_delete(d->db, k);
280     db->hdb_unlock(context, db);
281     if(code < 0)
282         return errno;
283     return 0;
284 }
285
286
287 static krb5_error_code
288 NDBM_close(krb5_context context, HDB *db)
289 {
290     struct ndbm_db *d = db->hdb_db;
291     dbm_close(d->db);
292     close(d->lock_fd);
293     free(d);
294     return 0;
295 }
296
297 static krb5_error_code
298 NDBM_open(krb5_context context, HDB *db, int flags, mode_t mode)
299 {
300     krb5_error_code ret;
301     struct ndbm_db *d = malloc(sizeof(*d));
302
303     if(d == NULL) {
304         krb5_set_error_message(context, ENOMEM, "malloc: out of memory");
305         return ENOMEM;
306     }
307
308     d->db = dbm_open((char*)db->hdb_name, flags, mode);
309     if(d->db == NULL){
310         ret = errno;
311         free(d);
312         krb5_set_error_message(context, ret, "dbm_open(%s): %s", db->hdb_name,
313                                strerror(ret));
314         return ret;
315     }
316
317     ret = open_lock_file(context, db->hdb_name, &d->lock_fd);
318     if (ret) {
319         ret = errno;
320         dbm_close(d->db);
321         free(d);
322         krb5_set_error_message(context, ret, "open(lock file): %s",
323                                strerror(ret));
324         return ret;
325     }
326
327     db->hdb_db = d;
328     if((flags & O_ACCMODE) == O_RDONLY)
329         ret = hdb_check_db_format(context, db);
330     else
331         ret = hdb_init_db(context, db);
332     if(ret == HDB_ERR_NOENTRY)
333         return 0;
334     if (ret) {
335         NDBM_close(context, db);
336         krb5_set_error_message(context, ret, "hdb_open: failed %s database %s",
337                                (flags & O_ACCMODE) == O_RDONLY ?
338                                "checking format of" : "initialize",
339                                db->hdb_name);
340     }
341     return ret;
342 }
343
344 krb5_error_code
345 hdb_ndbm_create(krb5_context context, HDB **db,
346                 const char *filename)
347 {
348     *db = calloc(1, sizeof(**db));
349     if (*db == NULL) {
350         krb5_set_error_message(context, ENOMEM, "malloc: out of memory");
351         return ENOMEM;
352     }
353
354     (*db)->hdb_db = NULL;
355     (*db)->hdb_name = strdup(filename);
356     if ((*db)->hdb_name == NULL) {
357         free(*db);
358         *db = NULL;
359         krb5_set_error_message(context, ENOMEM, "malloc: out of memory");
360         return ENOMEM;
361     }
362     (*db)->hdb_master_key_set = 0;
363     (*db)->hdb_openp = 0;
364     (*db)->hdb_capability_flags = HDB_CAP_F_HANDLE_ENTERPRISE_PRINCIPAL;
365     (*db)->hdb_open = NDBM_open;
366     (*db)->hdb_close = NDBM_close;
367     (*db)->hdb_fetch = _hdb_fetch;
368     (*db)->hdb_store = _hdb_store;
369     (*db)->hdb_remove = _hdb_remove;
370     (*db)->hdb_firstkey = NDBM_firstkey;
371     (*db)->hdb_nextkey= NDBM_nextkey;
372     (*db)->hdb_lock = NDBM_lock;
373     (*db)->hdb_unlock = NDBM_unlock;
374     (*db)->hdb_rename = NDBM_rename;
375     (*db)->hdb__get = NDBM__get;
376     (*db)->hdb__put = NDBM__put;
377     (*db)->hdb__del = NDBM__del;
378     (*db)->hdb_destroy = NDBM_destroy;
379     return 0;
380 }
381
382 #endif /* HAVE_NDBM */