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 "lib/util/debug.h"
24 #include "lib/util/fault.h"
25 #include "lib/util/talloc_stack.h"
26 #include "dbwrap/dbwrap.h"
27 #include "dbwrap/dbwrap_private.h"
28 #include "lib/util/util_tdb.h"
31 * Fall back using fetch if no genuine exists operation is provided
34 static int dbwrap_fallback_exists(struct db_context
*db
, TDB_DATA key
)
36 NTSTATUS status
= dbwrap_parse_record(db
, key
, NULL
, NULL
);
37 return NT_STATUS_IS_OK(status
) ? 1 : 0;
40 static int delete_record(struct db_record
*rec
, void *data
)
42 NTSTATUS status
= dbwrap_record_delete(rec
);
43 return NT_STATUS_IS_OK(status
) ? 0 : -1;
47 * Fallback wipe implementation using traverse and delete if no genuine
48 * wipe operation is provided
50 static int dbwrap_fallback_wipe(struct db_context
*db
)
52 NTSTATUS status
= dbwrap_trans_traverse(db
, delete_record
, NULL
);
53 return NT_STATUS_IS_OK(status
) ? 0 : -1;
56 static int do_nothing(struct db_record
*rec
, void *unused
)
62 * Fallback check operation: just traverse.
64 static int dbwrap_fallback_check(struct db_context
*db
)
66 NTSTATUS status
= dbwrap_traverse_read(db
, do_nothing
, NULL
, NULL
);
67 return NT_STATUS_IS_OK(status
) ? 0 : -1;
71 * Wrapper functions for the backend methods
74 TDB_DATA
dbwrap_record_get_key(const struct db_record
*rec
)
79 TDB_DATA
dbwrap_record_get_value(const struct db_record
*rec
)
84 NTSTATUS
dbwrap_record_store(struct db_record
*rec
, TDB_DATA data
, int flags
)
88 status
= rec
->store(rec
, data
, flags
);
89 if (!NT_STATUS_IS_OK(status
)) {
95 NTSTATUS
dbwrap_record_delete(struct db_record
*rec
)
99 status
= rec
->delete_rec(rec
);
100 if (!NT_STATUS_IS_OK(status
)) {
106 struct dbwrap_lock_order_state
{
107 struct db_context
**locked_dbs
;
108 struct db_context
*db
;
111 static void debug_lock_order(int level
, struct db_context
*dbs
[])
114 DEBUG(level
, ("lock order: "));
115 for (i
=0; i
<DBWRAP_LOCK_ORDER_MAX
; i
++) {
116 DEBUGADD(level
, (" %d:%s", i
+ 1, dbs
[i
] ? dbs
[i
]->name
: "<none>"));
118 DEBUGADD(level
, ("\n"));
121 static int dbwrap_lock_order_state_destructor(
122 struct dbwrap_lock_order_state
*s
)
124 int idx
= s
->db
->lock_order
- 1;
126 DEBUG(5, ("release lock order %d for %s\n",
127 (int)s
->db
->lock_order
, s
->db
->name
));
129 if (s
->locked_dbs
[idx
] != s
->db
) {
130 DEBUG(0, ("locked db at lock order %d is %s, expected %s\n",
131 idx
+ 1, s
->locked_dbs
[idx
]->name
, s
->db
->name
));
132 debug_lock_order(0, s
->locked_dbs
);
133 smb_panic("inconsistent lock_order\n");
136 s
->locked_dbs
[idx
] = NULL
;
138 debug_lock_order(10, s
->locked_dbs
);
144 static struct dbwrap_lock_order_state
*dbwrap_check_lock_order(
145 struct db_context
*db
, TALLOC_CTX
*mem_ctx
)
148 static struct db_context
*locked_dbs
[DBWRAP_LOCK_ORDER_MAX
];
149 struct dbwrap_lock_order_state
*state
= NULL
;
151 if (!DBWRAP_LOCK_ORDER_VALID(db
->lock_order
)) {
152 DEBUG(0,("Invalid lock order %d of %s\n",
153 (int)db
->lock_order
, db
->name
));
154 smb_panic("invalid lock_order\n");
158 DEBUG(5, ("check lock order %d for %s\n",
159 (int)db
->lock_order
, db
->name
));
162 for (idx
=db
->lock_order
- 1; idx
< DBWRAP_LOCK_ORDER_MAX
; idx
++) {
163 if (locked_dbs
[idx
] != NULL
) {
164 DEBUG(0, ("Lock order violation: Trying %s at %d while %s at %d is locked\n",
165 db
->name
, (int)db
->lock_order
, locked_dbs
[idx
]->name
, idx
+ 1));
166 debug_lock_order(0, locked_dbs
);
167 smb_panic("invalid lock_order");
172 state
= talloc(mem_ctx
, struct dbwrap_lock_order_state
);
174 DEBUG(1, ("talloc failed\n"));
178 state
->locked_dbs
= locked_dbs
;
179 talloc_set_destructor(state
, dbwrap_lock_order_state_destructor
);
181 locked_dbs
[db
->lock_order
- 1] = db
;
183 debug_lock_order(10, locked_dbs
);
188 static struct db_record
*dbwrap_fetch_locked_internal(
189 struct db_context
*db
, TALLOC_CTX
*mem_ctx
, TDB_DATA key
,
190 struct db_record
*(*db_fn
)(struct db_context
*db
, TALLOC_CTX
*mem_ctx
,
193 struct db_record
*rec
;
194 struct dbwrap_lock_order_state
*lock_order
= NULL
;
196 if (db
->lock_order
!= DBWRAP_LOCK_ORDER_NONE
) {
197 lock_order
= dbwrap_check_lock_order(db
, mem_ctx
);
198 if (lock_order
== NULL
) {
202 rec
= db_fn(db
, mem_ctx
, key
);
204 TALLOC_FREE(lock_order
);
207 (void)talloc_steal(rec
, lock_order
);
212 struct db_record
*dbwrap_fetch_locked(struct db_context
*db
,
216 return dbwrap_fetch_locked_internal(db
, mem_ctx
, key
,
220 struct db_record
*dbwrap_try_fetch_locked(struct db_context
*db
,
224 return dbwrap_fetch_locked_internal(
227 ? db
->try_fetch_locked
: db
->fetch_locked
);
230 struct db_context
*dbwrap_record_get_db(struct db_record
*rec
)
235 struct dbwrap_fetch_state
{
240 static void dbwrap_fetch_parser(TDB_DATA key
, TDB_DATA data
,
243 struct dbwrap_fetch_state
*state
=
244 (struct dbwrap_fetch_state
*)private_data
;
246 state
->data
.dsize
= data
.dsize
;
247 state
->data
.dptr
= (uint8_t *)talloc_memdup(state
->mem_ctx
, data
.dptr
,
251 NTSTATUS
dbwrap_fetch(struct db_context
*db
, TALLOC_CTX
*mem_ctx
,
252 TDB_DATA key
, TDB_DATA
*value
)
254 struct dbwrap_fetch_state state
;
258 return NT_STATUS_INVALID_PARAMETER
;
261 state
.mem_ctx
= mem_ctx
;
263 status
= dbwrap_parse_record(db
, key
, dbwrap_fetch_parser
, &state
);
264 if (!NT_STATUS_IS_OK(status
)) {
267 if ((state
.data
.dsize
!= 0) && (state
.data
.dptr
== NULL
)) {
268 return NT_STATUS_NO_MEMORY
;
274 bool dbwrap_exists(struct db_context
*db
, TDB_DATA key
)
277 if (db
->exists
!= NULL
) {
278 result
= db
->exists(db
, key
);
280 result
= dbwrap_fallback_exists(db
,key
);
282 return (result
== 1);
285 NTSTATUS
dbwrap_store(struct db_context
*db
, TDB_DATA key
,
286 TDB_DATA data
, int flags
)
288 struct db_record
*rec
;
290 TALLOC_CTX
*frame
= talloc_stackframe();
292 rec
= dbwrap_fetch_locked(db
, frame
, key
);
295 return NT_STATUS_NO_MEMORY
;
298 status
= dbwrap_record_store(rec
, data
, flags
);
303 NTSTATUS
dbwrap_delete(struct db_context
*db
, TDB_DATA key
)
305 struct db_record
*rec
;
307 TALLOC_CTX
*frame
= talloc_stackframe();
309 rec
= dbwrap_fetch_locked(db
, frame
, key
);
312 return NT_STATUS_NO_MEMORY
;
314 status
= dbwrap_record_delete(rec
);
319 NTSTATUS
dbwrap_traverse(struct db_context
*db
,
320 int (*f
)(struct db_record
*, void*),
324 int ret
= db
->traverse(db
, f
, private_data
);
327 return NT_STATUS_INTERNAL_DB_CORRUPTION
;
337 NTSTATUS
dbwrap_traverse_read(struct db_context
*db
,
338 int (*f
)(struct db_record
*, void*),
342 int ret
= db
->traverse_read(db
, f
, private_data
);
345 return NT_STATUS_INTERNAL_DB_CORRUPTION
;
355 static void dbwrap_null_parser(TDB_DATA key
, TDB_DATA val
, void* data
)
360 NTSTATUS
dbwrap_parse_record(struct db_context
*db
, TDB_DATA key
,
361 void (*parser
)(TDB_DATA key
, TDB_DATA data
,
365 if (parser
== NULL
) {
366 parser
= dbwrap_null_parser
;
368 return db
->parse_record(db
, key
, parser
, private_data
);
371 int dbwrap_wipe(struct db_context
*db
)
373 if (db
->wipe
== NULL
) {
374 return dbwrap_fallback_wipe(db
);
379 int dbwrap_check(struct db_context
*db
)
381 if (db
->check
== NULL
) {
382 return dbwrap_fallback_check(db
);
384 return db
->check(db
);
387 int dbwrap_get_seqnum(struct db_context
*db
)
389 return db
->get_seqnum(db
);
392 int dbwrap_transaction_start(struct db_context
*db
)
394 if (!db
->persistent
) {
396 * dbwrap_ctdb has two different data models for persistent
397 * and non-persistent databases. Transactions are supported
398 * only for the persistent databases. This check is here to
399 * prevent breakages of the cluster case, autobuild at this
400 * point only tests non-clustered Samba. Before removing this
401 * check, please make sure that this facility has also been
402 * added to dbwrap_ctdb.
406 DEBUG(1, ("transactions not supported on non-persistent "
407 "database %s\n", db
->name
));
410 return db
->transaction_start(db
);
413 NTSTATUS
dbwrap_transaction_start_nonblock(struct db_context
*db
)
415 if (db
->transaction_start_nonblock
) {
416 return db
->transaction_start_nonblock(db
);
418 return dbwrap_transaction_start(db
) == 0 ? NT_STATUS_OK
419 : NT_STATUS_UNSUCCESSFUL
;
423 int dbwrap_transaction_commit(struct db_context
*db
)
425 return db
->transaction_commit(db
);
428 int dbwrap_transaction_cancel(struct db_context
*db
)
430 return db
->transaction_cancel(db
);
433 size_t dbwrap_db_id(struct db_context
*db
, uint8_t *id
, size_t idlen
)
435 return db
->id(db
, id
, idlen
);
438 bool dbwrap_is_persistent(struct db_context
*db
)
440 return db
->persistent
;
443 const char *dbwrap_name(struct db_context
*db
)