dbwrap: use talloc_stackframe() in db_tdb_log_key()
[kai/samba.git] / lib / dbwrap / dbwrap_tdb.c
1 /*
2    Unix SMB/CIFS implementation.
3    Database interface wrapper around tdb
4    Copyright (C) Volker Lendecke 2005-2007
5
6    This program 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    This program 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 "includes.h"
21 #include "dbwrap/dbwrap.h"
22 #include "dbwrap/dbwrap_private.h"
23 #include "dbwrap/dbwrap_tdb.h"
24 #include "lib/tdb_wrap/tdb_wrap.h"
25 #include "lib/util/util_tdb.h"
26 #include "system/filesys.h"
27 #include "ccan/str/str.h"
28
29 struct db_tdb_ctx {
30         struct tdb_wrap *wtdb;
31
32         struct {
33                 dev_t dev;
34                 ino_t ino;
35         } id;
36 };
37
38 static NTSTATUS db_tdb_store(struct db_record *rec, TDB_DATA data, int flag);
39 static NTSTATUS db_tdb_delete(struct db_record *rec);
40
41 static void db_tdb_log_key(const char *prefix, TDB_DATA key)
42 {
43         size_t len;
44         char *keystr;
45         TALLOC_CTX *frame;
46         if (DEBUGLEVEL < 10) {
47                 return;
48         }
49         frame = talloc_stackframe();
50         len = key.dsize;
51         if (DEBUGLEVEL == 10) {
52                 /*
53                  * Only fully spam at debuglevel > 10
54                  */
55                 len = MIN(10, key.dsize);
56         }
57         keystr = hex_encode_talloc(frame, (unsigned char *)(key.dptr),
58                                    len);
59         DEBUG(10, ("%s key %s\n", prefix, keystr));
60         TALLOC_FREE(frame);
61 }
62
63 static int db_tdb_record_destr(struct db_record* data)
64 {
65         struct db_tdb_ctx *ctx =
66                 talloc_get_type_abort(data->private_data, struct db_tdb_ctx);
67
68         db_tdb_log_key("Unlocking", data->key);
69         tdb_chainunlock(ctx->wtdb->tdb, data->key);
70         return 0;
71 }
72
73 struct tdb_fetch_locked_state {
74         TALLOC_CTX *mem_ctx;
75         struct db_record *result;
76 };
77
78 static int db_tdb_fetchlock_parse(TDB_DATA key, TDB_DATA data,
79                                   void *private_data)
80 {
81         struct tdb_fetch_locked_state *state =
82                 (struct tdb_fetch_locked_state *)private_data;
83         struct db_record *result;
84
85         result = (struct db_record *)talloc_size(
86                 state->mem_ctx,
87                 sizeof(struct db_record) + key.dsize + data.dsize);
88
89         if (result == NULL) {
90                 return 0;
91         }
92         state->result = result;
93
94         result->key.dsize = key.dsize;
95         result->key.dptr = ((uint8_t *)result) + sizeof(struct db_record);
96         memcpy(result->key.dptr, key.dptr, key.dsize);
97
98         result->value.dsize = data.dsize;
99
100         if (data.dsize > 0) {
101                 result->value.dptr = result->key.dptr+key.dsize;
102                 memcpy(result->value.dptr, data.dptr, data.dsize);
103         }
104         else {
105                 result->value.dptr = NULL;
106         }
107
108         return 0;
109 }
110
111 static struct db_record *db_tdb_fetch_locked_internal(
112         struct db_context *db, TALLOC_CTX *mem_ctx, TDB_DATA key)
113 {
114         struct db_tdb_ctx *ctx = talloc_get_type_abort(db->private_data,
115                                                        struct db_tdb_ctx);
116         struct tdb_fetch_locked_state state;
117
118         state.mem_ctx = mem_ctx;
119         state.result = NULL;
120
121         if ((tdb_parse_record(ctx->wtdb->tdb, key, db_tdb_fetchlock_parse,
122                               &state) < 0) &&
123             (tdb_error(ctx->wtdb->tdb) != TDB_ERR_NOEXIST)) {
124                 tdb_chainunlock(ctx->wtdb->tdb, key);
125                 return NULL;
126         }
127
128         if (state.result == NULL) {
129                 db_tdb_fetchlock_parse(key, tdb_null, &state);
130         }
131
132         if (state.result == NULL) {
133                 tdb_chainunlock(ctx->wtdb->tdb, key);
134                 return NULL;
135         }
136
137         talloc_set_destructor(state.result, db_tdb_record_destr);
138
139         state.result->private_data = talloc_reference(state.result, ctx);
140         state.result->store = db_tdb_store;
141         state.result->delete_rec = db_tdb_delete;
142
143         DEBUG(10, ("Allocated locked data 0x%p\n", state.result));
144
145         return state.result;
146 }
147
148 static struct db_record *db_tdb_fetch_locked(
149         struct db_context *db, TALLOC_CTX *mem_ctx, TDB_DATA key)
150 {
151         struct db_tdb_ctx *ctx = talloc_get_type_abort(db->private_data,
152                                                        struct db_tdb_ctx);
153
154         db_tdb_log_key("Locking", key);
155         if (tdb_chainlock(ctx->wtdb->tdb, key) != 0) {
156                 DEBUG(3, ("tdb_chainlock failed\n"));
157                 return NULL;
158         }
159         return db_tdb_fetch_locked_internal(db, mem_ctx, key);
160 }
161
162 static struct db_record *db_tdb_fetch_locked_timeout(
163         struct db_context *db, TALLOC_CTX *mem_ctx, TDB_DATA key,
164         unsigned int timeout)
165 {
166         struct db_tdb_ctx *ctx = talloc_get_type_abort(db->private_data,
167                                                        struct db_tdb_ctx);
168
169         db_tdb_log_key("Locking with timeout ", key);
170         if (tdb_chainlock_with_timeout(ctx->wtdb->tdb, key, timeout) != 0) {
171                 DEBUG(3, ("tdb_chainlock_with_timeout failed\n"));
172                 return NULL;
173         }
174         return db_tdb_fetch_locked_internal(db, mem_ctx, key);
175 }
176
177 static struct db_record *db_tdb_try_fetch_locked(
178         struct db_context *db, TALLOC_CTX *mem_ctx, TDB_DATA key)
179 {
180         struct db_tdb_ctx *ctx = talloc_get_type_abort(db->private_data,
181                                                        struct db_tdb_ctx);
182
183         db_tdb_log_key("Trying to lock", key);
184         if (tdb_chainlock_nonblock(ctx->wtdb->tdb, key) != 0) {
185                 DEBUG(3, ("tdb_chainlock_nonblock failed\n"));
186                 return NULL;
187         }
188         return db_tdb_fetch_locked_internal(db, mem_ctx, key);
189 }
190
191
192 static int db_tdb_exists(struct db_context *db, TDB_DATA key)
193 {
194         struct db_tdb_ctx *ctx = talloc_get_type_abort(
195                 db->private_data, struct db_tdb_ctx);
196         return tdb_exists(ctx->wtdb->tdb, key);
197 }
198
199 static int db_tdb_wipe(struct db_context *db)
200 {
201         struct db_tdb_ctx *ctx = talloc_get_type_abort(
202                 db->private_data, struct db_tdb_ctx);
203         return tdb_wipe_all(ctx->wtdb->tdb);
204 }
205
206 static int db_tdb_check(struct db_context *db)
207 {
208         struct db_tdb_ctx *ctx = talloc_get_type_abort(
209                 db->private_data, struct db_tdb_ctx);
210         return tdb_check(ctx->wtdb->tdb, NULL, NULL);
211 }
212
213 struct db_tdb_parse_state {
214         void (*parser)(TDB_DATA key, TDB_DATA data,
215                        void *private_data);
216         void *private_data;
217 };
218
219 /*
220  * tdb_parse_record expects a parser returning int, mixing up tdb and
221  * parser errors. Wrap around that by always returning 0 and have
222  * dbwrap_parse_record expect a parser returning void.
223  */
224
225 static int db_tdb_parser(TDB_DATA key, TDB_DATA data, void *private_data)
226 {
227         struct db_tdb_parse_state *state =
228                 (struct db_tdb_parse_state *)private_data;
229         state->parser(key, data, state->private_data);
230         return 0;
231 }
232
233 static NTSTATUS db_tdb_parse(struct db_context *db, TDB_DATA key,
234                              void (*parser)(TDB_DATA key, TDB_DATA data,
235                                            void *private_data),
236                              void *private_data)
237 {
238         struct db_tdb_ctx *ctx = talloc_get_type_abort(
239                 db->private_data, struct db_tdb_ctx);
240         struct db_tdb_parse_state state;
241         int ret;
242
243         state.parser = parser;
244         state.private_data = private_data;
245
246         ret = tdb_parse_record(ctx->wtdb->tdb, key, db_tdb_parser, &state);
247
248         if (ret != 0) {
249                 return map_nt_error_from_tdb(tdb_error(ctx->wtdb->tdb));
250         }
251         return NT_STATUS_OK;
252 }
253
254 static NTSTATUS db_tdb_store(struct db_record *rec, TDB_DATA data, int flag)
255 {
256         struct db_tdb_ctx *ctx = talloc_get_type_abort(rec->private_data,
257                                                        struct db_tdb_ctx);
258
259         /*
260          * This has a bug: We need to replace rec->value for correct
261          * operation, but right now brlock and locking don't use the value
262          * anymore after it was stored.
263          */
264
265         return (tdb_store(ctx->wtdb->tdb, rec->key, data, flag) == 0) ?
266                 NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
267 }
268
269 static NTSTATUS db_tdb_delete(struct db_record *rec)
270 {
271         struct db_tdb_ctx *ctx = talloc_get_type_abort(rec->private_data,
272                                                        struct db_tdb_ctx);
273
274         if (tdb_delete(ctx->wtdb->tdb, rec->key) == 0) {
275                 return NT_STATUS_OK;
276         }
277
278         if (tdb_error(ctx->wtdb->tdb) == TDB_ERR_NOEXIST) {
279                 return NT_STATUS_NOT_FOUND;
280         }
281
282         return NT_STATUS_UNSUCCESSFUL;
283 }
284
285 struct db_tdb_traverse_ctx {
286         struct db_context *db;
287         int (*f)(struct db_record *rec, void *private_data);
288         void *private_data;
289 };
290
291 static int db_tdb_traverse_func(TDB_CONTEXT *tdb, TDB_DATA kbuf, TDB_DATA dbuf,
292                                 void *private_data)
293 {
294         struct db_tdb_traverse_ctx *ctx =
295                 (struct db_tdb_traverse_ctx *)private_data;
296         struct db_record rec;
297
298         rec.key = kbuf;
299         rec.value = dbuf;
300         rec.store = db_tdb_store;
301         rec.delete_rec = db_tdb_delete;
302         rec.private_data = ctx->db->private_data;
303         rec.db = ctx->db;
304
305         return ctx->f(&rec, ctx->private_data);
306 }
307
308 static int db_tdb_traverse(struct db_context *db,
309                            int (*f)(struct db_record *rec, void *private_data),
310                            void *private_data)
311 {
312         struct db_tdb_ctx *db_ctx =
313                 talloc_get_type_abort(db->private_data, struct db_tdb_ctx);
314         struct db_tdb_traverse_ctx ctx;
315
316         ctx.db = db;
317         ctx.f = f;
318         ctx.private_data = private_data;
319         return tdb_traverse(db_ctx->wtdb->tdb, db_tdb_traverse_func, &ctx);
320 }
321
322 static NTSTATUS db_tdb_store_deny(struct db_record *rec, TDB_DATA data, int flag)
323 {
324         return NT_STATUS_MEDIA_WRITE_PROTECTED;
325 }
326
327 static NTSTATUS db_tdb_delete_deny(struct db_record *rec)
328 {
329         return NT_STATUS_MEDIA_WRITE_PROTECTED;
330 }
331
332 static int db_tdb_traverse_read_func(TDB_CONTEXT *tdb, TDB_DATA kbuf, TDB_DATA dbuf,
333                                 void *private_data)
334 {
335         struct db_tdb_traverse_ctx *ctx =
336                 (struct db_tdb_traverse_ctx *)private_data;
337         struct db_record rec;
338
339         rec.key = kbuf;
340         rec.value = dbuf;
341         rec.store = db_tdb_store_deny;
342         rec.delete_rec = db_tdb_delete_deny;
343         rec.private_data = ctx->db->private_data;
344         rec.db = ctx->db;
345
346         return ctx->f(&rec, ctx->private_data);
347 }
348
349 static int db_tdb_traverse_read(struct db_context *db,
350                            int (*f)(struct db_record *rec, void *private_data),
351                            void *private_data)
352 {
353         struct db_tdb_ctx *db_ctx =
354                 talloc_get_type_abort(db->private_data, struct db_tdb_ctx);
355         struct db_tdb_traverse_ctx ctx;
356
357         ctx.db = db;
358         ctx.f = f;
359         ctx.private_data = private_data;
360         return tdb_traverse_read(db_ctx->wtdb->tdb, db_tdb_traverse_read_func, &ctx);
361 }
362
363 static int db_tdb_get_seqnum(struct db_context *db)
364
365 {
366         struct db_tdb_ctx *db_ctx =
367                 talloc_get_type_abort(db->private_data, struct db_tdb_ctx);
368         return tdb_get_seqnum(db_ctx->wtdb->tdb);
369 }
370
371 static int db_tdb_transaction_start(struct db_context *db)
372 {
373         struct db_tdb_ctx *db_ctx =
374                 talloc_get_type_abort(db->private_data, struct db_tdb_ctx);
375         return tdb_transaction_start(db_ctx->wtdb->tdb) ? -1 : 0;
376 }
377
378 static NTSTATUS db_tdb_transaction_start_nonblock(struct db_context *db)
379 {
380         struct db_tdb_ctx *db_ctx =
381                 talloc_get_type_abort(db->private_data, struct db_tdb_ctx);
382         int ret;
383
384         ret = tdb_transaction_start_nonblock(db_ctx->wtdb->tdb);
385         if (ret != 0) {
386                 return map_nt_error_from_tdb(tdb_error(db_ctx->wtdb->tdb));
387         }
388         return NT_STATUS_OK;
389 }
390
391 static int db_tdb_transaction_commit(struct db_context *db)
392 {
393         struct db_tdb_ctx *db_ctx =
394                 talloc_get_type_abort(db->private_data, struct db_tdb_ctx);
395         return tdb_transaction_commit(db_ctx->wtdb->tdb) ? -1 : 0;
396 }
397
398 static int db_tdb_transaction_cancel(struct db_context *db)
399 {
400         struct db_tdb_ctx *db_ctx =
401                 talloc_get_type_abort(db->private_data, struct db_tdb_ctx);
402         tdb_transaction_cancel(db_ctx->wtdb->tdb);
403         return 0;
404 }
405
406 static void db_tdb_id(struct db_context *db, const uint8_t **id, size_t *idlen)
407 {
408         struct db_tdb_ctx *db_ctx =
409                 talloc_get_type_abort(db->private_data, struct db_tdb_ctx);
410         *id = (uint8_t *)&db_ctx->id;
411         *idlen = sizeof(db_ctx->id);
412 }
413
414 struct db_context *db_open_tdb(TALLOC_CTX *mem_ctx,
415                                struct loadparm_context *lp_ctx,
416                                const char *name,
417                                int hash_size, int tdb_flags,
418                                int open_flags, mode_t mode,
419                                enum dbwrap_lock_order lock_order)
420 {
421         struct db_context *result = NULL;
422         struct db_tdb_ctx *db_tdb;
423         struct stat st;
424
425         /* Extra paranoia. */
426         if (name && strends(name, ".ntdb")) {
427                 DEBUG(0, ("can't try to open %s with tdb!\n", name));
428                 return NULL;
429         }
430
431         result = talloc_zero(mem_ctx, struct db_context);
432         if (result == NULL) {
433                 DEBUG(0, ("talloc failed\n"));
434                 goto fail;
435         }
436
437         result->private_data = db_tdb = talloc(result, struct db_tdb_ctx);
438         if (db_tdb == NULL) {
439                 DEBUG(0, ("talloc failed\n"));
440                 goto fail;
441         }
442         result->lock_order = lock_order;
443
444         db_tdb->wtdb = tdb_wrap_open(db_tdb, name, hash_size, tdb_flags,
445                                      open_flags, mode, lp_ctx);
446         if (db_tdb->wtdb == NULL) {
447                 DEBUG(3, ("Could not open tdb: %s\n", strerror(errno)));
448                 goto fail;
449         }
450
451         ZERO_STRUCT(db_tdb->id);
452
453         if (fstat(tdb_fd(db_tdb->wtdb->tdb), &st) == -1) {
454                 DEBUG(3, ("fstat failed: %s\n", strerror(errno)));
455                 goto fail;
456         }
457         db_tdb->id.dev = st.st_dev;
458         db_tdb->id.ino = st.st_ino;
459
460         result->fetch_locked = db_tdb_fetch_locked;
461         result->fetch_locked_timeout = db_tdb_fetch_locked_timeout;
462         result->try_fetch_locked = db_tdb_try_fetch_locked;
463         result->traverse = db_tdb_traverse;
464         result->traverse_read = db_tdb_traverse_read;
465         result->parse_record = db_tdb_parse;
466         result->get_seqnum = db_tdb_get_seqnum;
467         result->persistent = ((tdb_flags & TDB_CLEAR_IF_FIRST) == 0);
468         result->transaction_start = db_tdb_transaction_start;
469         result->transaction_start_nonblock = db_tdb_transaction_start_nonblock;
470         result->transaction_commit = db_tdb_transaction_commit;
471         result->transaction_cancel = db_tdb_transaction_cancel;
472         result->exists = db_tdb_exists;
473         result->wipe = db_tdb_wipe;
474         result->id = db_tdb_id;
475         result->check = db_tdb_check;
476         result->stored_callback = NULL;
477         result->name = tdb_name(db_tdb->wtdb->tdb);
478         result->hash_size = hash_size;
479         return result;
480
481  fail:
482         if (result != NULL) {
483                 TALLOC_FREE(result);
484         }
485         return NULL;
486 }