2 Unix SMB/CIFS implementation.
3 Database interface wrapper
4 Copyright (C) Jim McDonough <jmcd@us.ibm.com> 2006
6 Major code contributions from Aleksey Fedoseev (fedoseev@ru.ibm.com)
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>.
23 #include "dbwrap/dbwrap.h"
24 #include "dbwrap/dbwrap_private.h"
25 #include "lib/util/util_tdb.h"
28 * Fall back using fetch if no genuine exists operation is provided
31 static int dbwrap_fallback_exists(struct db_context *db, TDB_DATA key)
33 NTSTATUS status = dbwrap_parse_record(db, key, NULL, NULL);
34 return NT_STATUS_IS_OK(status) ? 1 : 0;
37 static int delete_record(struct db_record *rec, void *data)
39 NTSTATUS status = dbwrap_record_delete(rec);
40 return NT_STATUS_IS_OK(status) ? 0 : -1;
44 * Fallback wipe implementation using traverse and delete if no genuine
45 * wipe operation is provided
47 static int dbwrap_fallback_wipe(struct db_context *db)
49 NTSTATUS status = dbwrap_trans_traverse(db, delete_record, NULL);
50 return NT_STATUS_IS_OK(status) ? 0 : -1;
53 static int do_nothing(struct db_record *rec, void *unused)
59 * Fallback check operation: just traverse.
61 static int dbwrap_fallback_check(struct db_context *db)
63 NTSTATUS status = dbwrap_traverse_read(db, do_nothing, NULL, NULL);
64 return NT_STATUS_IS_OK(status) ? 0 : -1;
68 * Wrapper functions for the backend methods
71 TDB_DATA dbwrap_record_get_key(const struct db_record *rec)
76 TDB_DATA dbwrap_record_get_value(const struct db_record *rec)
81 NTSTATUS dbwrap_record_store(struct db_record *rec, TDB_DATA data, int flags)
84 struct db_context *db;
86 status = rec->store(rec, data, flags);
87 if (!NT_STATUS_IS_OK(status)) {
91 if (db->stored_callback != NULL) {
92 db->stored_callback(db, rec,
93 db->stored_callback_private_data);
98 void dbwrap_set_stored_callback(
99 struct db_context *db,
100 void (*cb)(struct db_context *db, struct db_record *rec,
104 db->stored_callback = cb;
105 db->stored_callback_private_data = private_data;
108 NTSTATUS dbwrap_record_delete(struct db_record *rec)
111 struct db_context *db;
113 status = rec->delete_rec(rec);
114 if (!NT_STATUS_IS_OK(status)) {
118 if (db->stored_callback != NULL) {
119 db->stored_callback(db, rec,
120 db->stored_callback_private_data);
125 struct dbwrap_lock_order_state {
126 uint8_t *plock_order_mask;
130 static int dbwrap_lock_order_state_destructor(
131 struct dbwrap_lock_order_state *s)
133 *s->plock_order_mask &= ~s->bitmask;
137 static struct dbwrap_lock_order_state *dbwrap_check_lock_order(
138 struct db_context *db, TALLOC_CTX *mem_ctx)
141 * Store the lock_order of currently locked records as bits in
142 * "lock_order_mask". We only use levels 1,2,3 right now, so a
143 * single uint8_t is enough.
145 static uint8_t lock_order_mask;
147 struct dbwrap_lock_order_state *state;
151 if (db->lock_order == 0) {
153 * lock order 0 is for example for dbwrap_rbt without
154 * real locking. Return state nevertheless to avoid
157 return talloc(mem_ctx, struct dbwrap_lock_order_state);
161 * We fill bits from the high bits, to be able to use
162 * "ffs(lock_order_mask)"
164 idx = sizeof(lock_order_mask)*8 - db->lock_order;
166 used = ffs(lock_order_mask);
168 DEBUG(5, ("used=%d, lock_order=%d, idx=%d\n", used,
169 (int)db->lock_order, (int)idx));
171 if ((used != 0) && (used-1 <= idx)) {
172 DEBUG(0, ("Lock order violation: Trying %d, order_mask=%x\n",
173 (int)db->lock_order, (int)lock_order_mask));
177 state = talloc(mem_ctx, struct dbwrap_lock_order_state);
179 DEBUG(1, ("talloc failed\n"));
182 state->bitmask = 1 << idx;
183 state->plock_order_mask = &lock_order_mask;
185 talloc_set_destructor(state, dbwrap_lock_order_state_destructor);
186 lock_order_mask |= state->bitmask;
191 static struct db_record *dbwrap_fetch_locked_internal(
192 struct db_context *db, TALLOC_CTX *mem_ctx, TDB_DATA key,
193 struct db_record *(*db_fn)(struct db_context *db, TALLOC_CTX *mem_ctx,
196 struct db_record *rec;
197 struct dbwrap_lock_order_state *lock_order;
198 TALLOC_CTX *frame = talloc_stackframe();
200 lock_order = dbwrap_check_lock_order(db, frame);
201 if (lock_order == NULL) {
205 rec = db_fn(db, mem_ctx, key);
210 (void)talloc_steal(rec, lock_order);
216 struct db_record *dbwrap_fetch_locked(struct db_context *db,
220 return dbwrap_fetch_locked_internal(db, mem_ctx, key,
224 struct db_record *dbwrap_try_fetch_locked(struct db_context *db,
228 return dbwrap_fetch_locked_internal(
231 ? db->try_fetch_locked : db->fetch_locked);
234 struct db_record *dbwrap_fetch_locked_timeout(struct db_context *db,
237 unsigned int timeout)
239 struct db_record *rec;
240 struct dbwrap_lock_order_state *lock_order;
241 TALLOC_CTX *frame = talloc_stackframe();
243 lock_order = dbwrap_check_lock_order(db, frame);
244 if (lock_order == NULL) {
248 rec = db->fetch_locked_timeout
249 ? db->fetch_locked_timeout(db, mem_ctx, key, timeout)
250 : db->fetch_locked(db, mem_ctx, key);
255 (void)talloc_steal(rec, lock_order);
261 struct db_context *dbwrap_record_get_db(struct db_record *rec)
266 struct dbwrap_fetch_state {
271 static void dbwrap_fetch_parser(TDB_DATA key, TDB_DATA data,
274 struct dbwrap_fetch_state *state =
275 (struct dbwrap_fetch_state *)private_data;
277 state->data.dsize = data.dsize;
278 state->data.dptr = (uint8_t *)talloc_memdup(state->mem_ctx, data.dptr,
282 NTSTATUS dbwrap_fetch(struct db_context *db, TALLOC_CTX *mem_ctx,
283 TDB_DATA key, TDB_DATA *value)
285 struct dbwrap_fetch_state state;
289 return NT_STATUS_INVALID_PARAMETER;
292 state.mem_ctx = mem_ctx;
294 status = dbwrap_parse_record(db, key, dbwrap_fetch_parser, &state);
295 if (!NT_STATUS_IS_OK(status)) {
298 if ((state.data.dsize != 0) && (state.data.dptr == NULL)) {
299 return NT_STATUS_NO_MEMORY;
305 bool dbwrap_exists(struct db_context *db, TDB_DATA key)
308 if (db->exists != NULL) {
309 result = db->exists(db, key);
311 result = dbwrap_fallback_exists(db,key);
313 return (result == 1);
316 NTSTATUS dbwrap_store(struct db_context *db, TDB_DATA key,
317 TDB_DATA data, int flags)
319 struct db_record *rec;
321 TALLOC_CTX *frame = talloc_stackframe();
323 rec = dbwrap_fetch_locked(db, frame, key);
326 return NT_STATUS_NO_MEMORY;
329 status = dbwrap_record_store(rec, data, flags);
334 NTSTATUS dbwrap_delete(struct db_context *db, TDB_DATA key)
336 struct db_record *rec;
338 TALLOC_CTX *frame = talloc_stackframe();
340 rec = dbwrap_fetch_locked(db, frame, key);
343 return NT_STATUS_NO_MEMORY;
345 status = dbwrap_record_delete(rec);
350 NTSTATUS dbwrap_traverse(struct db_context *db,
351 int (*f)(struct db_record*, void*),
355 int ret = db->traverse(db, f, private_data);
358 return NT_STATUS_INTERNAL_DB_CORRUPTION;
368 NTSTATUS dbwrap_traverse_read(struct db_context *db,
369 int (*f)(struct db_record*, void*),
373 int ret = db->traverse_read(db, f, private_data);
376 return NT_STATUS_INTERNAL_DB_CORRUPTION;
386 static void dbwrap_null_parser(TDB_DATA key, TDB_DATA val, void* data)
391 NTSTATUS dbwrap_parse_record(struct db_context *db, TDB_DATA key,
392 void (*parser)(TDB_DATA key, TDB_DATA data,
396 if (parser == NULL) {
397 parser = dbwrap_null_parser;
399 return db->parse_record(db, key, parser, private_data);
402 int dbwrap_wipe(struct db_context *db)
404 if (db->wipe == NULL) {
405 return dbwrap_fallback_wipe(db);
410 int dbwrap_check(struct db_context *db)
412 if (db->check == NULL) {
413 return dbwrap_fallback_check(db);
415 return db->check(db);
418 int dbwrap_get_seqnum(struct db_context *db)
420 return db->get_seqnum(db);
423 int dbwrap_transaction_start(struct db_context *db)
425 return db->transaction_start(db);
428 NTSTATUS dbwrap_transaction_start_nonblock(struct db_context *db)
430 if (db->transaction_start_nonblock) {
431 return db->transaction_start_nonblock(db);
433 return dbwrap_transaction_start(db) == 0 ? NT_STATUS_OK
434 : NT_STATUS_UNSUCCESSFUL;
438 int dbwrap_transaction_commit(struct db_context *db)
440 return db->transaction_commit(db);
443 int dbwrap_transaction_cancel(struct db_context *db)
445 return db->transaction_cancel(db);
448 void dbwrap_db_id(struct db_context *db, const uint8_t **id, size_t *idlen)
450 db->id(db, id, idlen);