2 Unix SMB/CIFS implementation.
3 Database interface wrapper around ntdb
4 Copyright (C) Volker Lendecke 2005-2007
5 Copyright (C) Rusty Russell 2012
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>.
22 #include "dbwrap/dbwrap.h"
23 #include "dbwrap/dbwrap_private.h"
24 #include "dbwrap/dbwrap_ntdb.h"
25 #include "system/filesys.h"
26 #include "lib/util/util_ntdb.h"
27 #include "ccan/str/str.h"
30 struct ntdb_context
*ntdb
;
38 static int tdb_store_flag_to_ntdb(int tdb_flag
)
41 /* In fact, any value defaults to TDB_REPLACE in tdb! */
50 smb_panic("unknown tdb_flag");
52 return -1; /* NOTREACHED */
55 static NTSTATUS
db_ntdb_store(struct db_record
*rec
, NTDB_DATA data
, int flag
)
57 int ntdb_flag
= tdb_store_flag_to_ntdb(flag
);
58 struct db_ntdb_ctx
*ctx
= talloc_get_type_abort(rec
->private_data
,
62 * This has a bug: We need to replace rec->value for correct
63 * operation, but right now brlock and locking don't use the value
64 * anymore after it was stored.
67 if (ntdb_store(ctx
->ntdb
, rec
->key
, data
, ntdb_flag
) == NTDB_SUCCESS
) {
70 return NT_STATUS_UNSUCCESSFUL
;
73 static NTSTATUS
db_ntdb_delete(struct db_record
*rec
)
76 struct db_ntdb_ctx
*ctx
= talloc_get_type_abort(rec
->private_data
,
79 err
= ntdb_delete(ctx
->ntdb
, rec
->key
);
80 if (err
== NTDB_SUCCESS
) {
84 if (err
== NTDB_ERR_NOEXIST
) {
85 return NT_STATUS_NOT_FOUND
;
88 return NT_STATUS_UNSUCCESSFUL
;
91 static void db_ntdb_log_key(const char *prefix
, NTDB_DATA key
)
96 if (DEBUGLEVEL
< 10) {
100 if (DEBUGLEVEL
== 10) {
102 * Only fully spam at debuglevel > 10
104 len
= MIN(10, key
.dsize
);
106 keystr
= hex_encode_talloc(talloc_tos(), (unsigned char *)(key
.dptr
),
108 DEBUG(10, ("%s key %s\n", prefix
, keystr
));
112 static int db_ntdb_record_destr(struct db_record
* data
)
114 struct db_ntdb_ctx
*ctx
=
115 talloc_get_type_abort(data
->private_data
, struct db_ntdb_ctx
);
117 db_ntdb_log_key("Unlocking", data
->key
);
118 ntdb_chainunlock(ctx
->ntdb
, data
->key
);
122 struct ntdb_fetch_locked_state
{
124 struct db_record
*result
;
127 static enum NTDB_ERROR
db_ntdb_fetchlock_parse(NTDB_DATA key
, NTDB_DATA data
,
128 struct ntdb_fetch_locked_state
*state
)
130 struct db_record
*result
;
132 result
= (struct db_record
*)talloc_size(
134 sizeof(struct db_record
) + key
.dsize
+ data
.dsize
);
136 if (result
== NULL
) {
139 state
->result
= result
;
141 result
->key
.dsize
= key
.dsize
;
142 result
->key
.dptr
= ((uint8_t *)result
) + sizeof(struct db_record
);
143 memcpy(result
->key
.dptr
, key
.dptr
, key
.dsize
);
145 result
->value
.dsize
= data
.dsize
;
147 if (data
.dsize
> 0) {
148 result
->value
.dptr
= result
->key
.dptr
+key
.dsize
;
149 memcpy(result
->value
.dptr
, data
.dptr
, data
.dsize
);
152 result
->value
.dptr
= NULL
;
158 static struct db_record
*db_ntdb_fetch_locked_internal(
159 struct db_context
*db
, TALLOC_CTX
*mem_ctx
, NTDB_DATA key
)
161 struct db_ntdb_ctx
*ctx
= talloc_get_type_abort(db
->private_data
,
163 struct ntdb_fetch_locked_state state
;
165 NTDB_DATA null
= { NULL
, 0 };
167 state
.mem_ctx
= mem_ctx
;
170 err
= ntdb_parse_record(ctx
->ntdb
, key
, db_ntdb_fetchlock_parse
,
172 if (err
!= NTDB_SUCCESS
&& err
!= NTDB_ERR_NOEXIST
) {
173 ntdb_chainunlock(ctx
->ntdb
, key
);
177 if (state
.result
== NULL
) {
178 db_ntdb_fetchlock_parse(key
, null
, &state
);
181 if (state
.result
== NULL
) {
182 ntdb_chainunlock(ctx
->ntdb
, key
);
186 talloc_set_destructor(state
.result
, db_ntdb_record_destr
);
188 state
.result
->private_data
= talloc_reference(state
.result
, ctx
);
189 state
.result
->store
= db_ntdb_store
;
190 state
.result
->delete_rec
= db_ntdb_delete
;
192 DEBUG(10, ("Allocated locked data 0x%p\n", state
.result
));
197 static struct db_record
*db_ntdb_fetch_locked(
198 struct db_context
*db
, TALLOC_CTX
*mem_ctx
, NTDB_DATA key
)
200 struct db_ntdb_ctx
*ctx
= talloc_get_type_abort(db
->private_data
,
203 db_ntdb_log_key("Locking", key
);
204 if (ntdb_chainlock(ctx
->ntdb
, key
) != 0) {
205 DEBUG(3, ("ntdb_chainlock failed\n"));
208 return db_ntdb_fetch_locked_internal(db
, mem_ctx
, key
);
211 /* Proxy which sets waitflag to false so we never block. */
212 static int lock_nonblock(int fd
, int rw
, off_t off
, off_t len
, bool waitflag
,
215 struct ntdb_attribute_flock
*orig
= _orig
;
217 return orig
->lock(fd
, rw
, off
, len
, false, orig
->data
);
220 static enum NTDB_ERROR
enable_nonblock(struct ntdb_context
*ntdb
,
221 union ntdb_attribute
*orig
)
223 union ntdb_attribute locking
;
224 enum NTDB_ERROR ecode
;
226 orig
->base
.attr
= NTDB_ATTRIBUTE_FLOCK
;
227 ecode
= ntdb_get_attribute(ntdb
, orig
);
228 if (ecode
!= NTDB_SUCCESS
) {
232 /* Replace locking function with our own. */
234 locking
.flock
.data
= orig
;
235 locking
.flock
.lock
= lock_nonblock
;
237 return ntdb_set_attribute(ntdb
, &locking
);
240 static void disable_nonblock(struct ntdb_context
*ntdb
)
242 ntdb_unset_attribute(ntdb
, NTDB_ATTRIBUTE_FLOCK
);
245 static enum NTDB_ERROR
ntdb_chainlock_nonblock(struct ntdb_context
*ntdb
,
248 union ntdb_attribute orig
;
249 enum NTDB_ERROR ecode
;
251 ecode
= enable_nonblock(ntdb
, &orig
);
253 ecode
= ntdb_chainlock(ntdb
, key
);
254 disable_nonblock(ntdb
);
259 static struct db_record
*db_ntdb_try_fetch_locked(
260 struct db_context
*db
, TALLOC_CTX
*mem_ctx
, TDB_DATA key
)
262 struct db_ntdb_ctx
*ctx
= talloc_get_type_abort(db
->private_data
,
265 db_ntdb_log_key("Trying to lock", key
);
266 if (ntdb_chainlock_nonblock(ctx
->ntdb
, key
) != 0) {
267 DEBUG(3, ("ntdb_chainlock_nonblock failed\n"));
270 return db_ntdb_fetch_locked_internal(db
, mem_ctx
, key
);
273 static int db_ntdb_exists(struct db_context
*db
, TDB_DATA key
)
275 struct db_ntdb_ctx
*ctx
= talloc_get_type_abort(
276 db
->private_data
, struct db_ntdb_ctx
);
277 return ntdb_exists(ctx
->ntdb
, key
);
280 static int db_ntdb_wipe(struct db_context
*db
)
282 struct db_ntdb_ctx
*ctx
= talloc_get_type_abort(
283 db
->private_data
, struct db_ntdb_ctx
);
284 if (ntdb_wipe_all(ctx
->ntdb
) != NTDB_SUCCESS
) {
290 static int db_ntdb_check(struct db_context
*db
)
292 struct db_ntdb_ctx
*ctx
= talloc_get_type_abort(
293 db
->private_data
, struct db_ntdb_ctx
);
294 if (ntdb_check(ctx
->ntdb
, NULL
, NULL
) != NTDB_SUCCESS
) {
300 struct db_ntdb_parse_state
{
301 void (*parser
)(TDB_DATA key
, TDB_DATA data
,
307 * ntdb_parse_record expects a parser returning enum NTDB_ERROR,
308 * mixing up ntdb and parser errors. Wrap around that by always
309 * returning NTDB_SUCCESS and have dbwrap_parse_record expect a parser
313 static enum NTDB_ERROR
db_ntdb_parser(NTDB_DATA key
, NTDB_DATA data
,
314 struct db_ntdb_parse_state
*state
)
316 state
->parser(key
, data
, state
->private_data
);
320 static NTSTATUS
db_ntdb_parse(struct db_context
*db
, TDB_DATA key
,
321 void (*parser
)(TDB_DATA key
, TDB_DATA data
,
325 struct db_ntdb_ctx
*ctx
= talloc_get_type_abort(
326 db
->private_data
, struct db_ntdb_ctx
);
327 struct db_ntdb_parse_state state
;
330 state
.parser
= parser
;
331 state
.private_data
= private_data
;
333 err
= ntdb_parse_record(ctx
->ntdb
, key
, db_ntdb_parser
, &state
);
334 return map_nt_error_from_ntdb(err
);
337 struct db_ntdb_traverse_ctx
{
338 struct db_context
*db
;
339 int (*f
)(struct db_record
*rec
, void *private_data
);
343 static int db_ntdb_traverse_func(struct ntdb_context
*ntdb
,
344 NTDB_DATA kbuf
, NTDB_DATA dbuf
,
345 struct db_ntdb_traverse_ctx
*ctx
)
347 struct db_record rec
;
351 rec
.store
= db_ntdb_store
;
352 rec
.delete_rec
= db_ntdb_delete
;
353 rec
.private_data
= ctx
->db
->private_data
;
356 return ctx
->f(&rec
, ctx
->private_data
);
359 static int db_ntdb_traverse(struct db_context
*db
,
360 int (*f
)(struct db_record
*rec
, void *private_data
),
363 struct db_ntdb_ctx
*db_ctx
=
364 talloc_get_type_abort(db
->private_data
, struct db_ntdb_ctx
);
365 struct db_ntdb_traverse_ctx ctx
;
370 ctx
.private_data
= private_data
;
371 ret
= ntdb_traverse(db_ctx
->ntdb
, db_ntdb_traverse_func
, &ctx
);
377 /* Make sure we don't truncate! */
378 if ((int)ret
!= ret
) {
384 static NTSTATUS
db_ntdb_store_deny(struct db_record
*rec
, NTDB_DATA data
, int flag
)
386 return NT_STATUS_MEDIA_WRITE_PROTECTED
;
389 static NTSTATUS
db_ntdb_delete_deny(struct db_record
*rec
)
391 return NT_STATUS_MEDIA_WRITE_PROTECTED
;
394 static int db_ntdb_traverse_read_func(struct ntdb_context
*ntdb
,
395 NTDB_DATA kbuf
, NTDB_DATA dbuf
,
396 struct db_ntdb_traverse_ctx
*ctx
)
398 struct db_record rec
;
402 rec
.store
= db_ntdb_store_deny
;
403 rec
.delete_rec
= db_ntdb_delete_deny
;
404 rec
.private_data
= ctx
->db
->private_data
;
407 return ctx
->f(&rec
, ctx
->private_data
);
410 static int db_ntdb_traverse_read(struct db_context
*db
,
411 int (*f
)(struct db_record
*rec
,
415 struct db_ntdb_ctx
*db_ctx
=
416 talloc_get_type_abort(db
->private_data
, struct db_ntdb_ctx
);
417 struct db_ntdb_traverse_ctx ctx
;
422 ctx
.private_data
= private_data
;
424 /* This is a bit of paranoia to check that f() isn't altering
426 if (ntdb_get_flags(db_ctx
->ntdb
) & NTDB_RDONLY
) {
427 ret
= ntdb_traverse(db_ctx
->ntdb
, db_ntdb_traverse_read_func
,
430 ntdb_add_flag(db_ctx
->ntdb
, NTDB_RDONLY
);
431 ret
= ntdb_traverse(db_ctx
->ntdb
, db_ntdb_traverse_read_func
,
433 ntdb_remove_flag(db_ctx
->ntdb
, NTDB_RDONLY
);
440 /* Make sure we don't truncate! */
441 if ((int)ret
!= ret
) {
447 static int db_ntdb_get_seqnum(struct db_context
*db
)
450 struct db_ntdb_ctx
*db_ctx
=
451 talloc_get_type_abort(db
->private_data
, struct db_ntdb_ctx
);
452 return ntdb_get_seqnum(db_ctx
->ntdb
);
455 static int db_ntdb_transaction_start(struct db_context
*db
)
457 struct db_ntdb_ctx
*db_ctx
=
458 talloc_get_type_abort(db
->private_data
, struct db_ntdb_ctx
);
459 return ntdb_transaction_start(db_ctx
->ntdb
) == NTDB_SUCCESS
? 0 : -1;
462 static NTSTATUS
db_ntdb_transaction_start_nonblock(struct db_context
*db
)
464 union ntdb_attribute orig
;
465 enum NTDB_ERROR ecode
;
466 struct db_ntdb_ctx
*db_ctx
=
467 talloc_get_type_abort(db
->private_data
, struct db_ntdb_ctx
);
469 ecode
= enable_nonblock(db_ctx
->ntdb
, &orig
);
471 ecode
= ntdb_transaction_start(db_ctx
->ntdb
);
472 disable_nonblock(db_ctx
->ntdb
);
474 return map_nt_error_from_ntdb(ecode
);
477 static int db_ntdb_transaction_commit(struct db_context
*db
)
479 struct db_ntdb_ctx
*db_ctx
=
480 talloc_get_type_abort(db
->private_data
, struct db_ntdb_ctx
);
481 return ntdb_transaction_commit(db_ctx
->ntdb
) == NTDB_SUCCESS
? 0 : -1;
484 static int db_ntdb_transaction_cancel(struct db_context
*db
)
486 struct db_ntdb_ctx
*db_ctx
=
487 talloc_get_type_abort(db
->private_data
, struct db_ntdb_ctx
);
488 ntdb_transaction_cancel(db_ctx
->ntdb
);
492 static void db_ntdb_id(struct db_context
*db
, const uint8_t **id
, size_t *idlen
)
494 struct db_ntdb_ctx
*db_ctx
=
495 talloc_get_type_abort(db
->private_data
, struct db_ntdb_ctx
);
496 *id
= (uint8_t *)&db_ctx
->id
;
497 *idlen
= sizeof(db_ctx
->id
);
500 /* Don't ask this to open a .tdb file: dbwrap_local_open will catch that. */
501 struct db_context
*db_open_ntdb(TALLOC_CTX
*mem_ctx
,
502 struct loadparm_context
*lp_ctx
,
503 const char *ntdbname
,
504 int hash_size
, int ntdb_flags
,
505 int open_flags
, mode_t mode
,
506 enum dbwrap_lock_order lock_order
,
507 uint64_t dbwrap_flags
)
509 struct db_context
*result
= NULL
;
510 struct db_ntdb_ctx
*db_ntdb
;
512 union ntdb_attribute hattr
;
514 if ((ntdb_flags
& NTDB_INTERNAL
) && !ntdbname
) {
515 ntdbname
= "unnamed";
518 /* Extra paranoia. */
519 if (strends(ntdbname
, ".tdb")) {
520 DEBUG(0, ("can't try to open %s with ntdb!", ntdbname
));
524 /* We only use this if hsize is non-zero. */
525 hattr
.base
.attr
= NTDB_ATTRIBUTE_HASHSIZE
;
526 hattr
.base
.next
= NULL
;
527 hattr
.hashsize
.size
= hash_size
;
529 result
= talloc_zero(mem_ctx
, struct db_context
);
530 if (result
== NULL
) {
531 DEBUG(0, ("talloc failed\n"));
535 result
->private_data
= db_ntdb
= talloc(result
, struct db_ntdb_ctx
);
536 if (db_ntdb
== NULL
) {
537 DEBUG(0, ("talloc failed\n"));
540 result
->lock_order
= lock_order
;
542 db_ntdb
->ntdb
= ntdb_new(db_ntdb
, ntdbname
, ntdb_flags
,
544 hash_size
? &hattr
: NULL
, lp_ctx
);
545 if (db_ntdb
->ntdb
== NULL
) {
546 DEBUG(3, ("Could not open ntdb %s: %s\n",
547 ntdbname
, strerror(errno
)));
551 ZERO_STRUCT(db_ntdb
->id
);
553 if (fstat(ntdb_fd(db_ntdb
->ntdb
), &st
) == -1) {
554 DEBUG(3, ("fstat failed: %s\n", strerror(errno
)));
557 db_ntdb
->id
.dev
= st
.st_dev
;
558 db_ntdb
->id
.ino
= st
.st_ino
;
560 result
->fetch_locked
= db_ntdb_fetch_locked
;
561 result
->try_fetch_locked
= db_ntdb_try_fetch_locked
;
562 result
->traverse
= db_ntdb_traverse
;
563 result
->traverse_read
= db_ntdb_traverse_read
;
564 result
->parse_record
= db_ntdb_parse
;
565 result
->get_seqnum
= db_ntdb_get_seqnum
;
566 result
->persistent
= ((ntdb_flags
& NTDB_CLEAR_IF_FIRST
) == 0);
567 result
->transaction_start
= db_ntdb_transaction_start
;
568 result
->transaction_start_nonblock
= db_ntdb_transaction_start_nonblock
;
569 result
->transaction_commit
= db_ntdb_transaction_commit
;
570 result
->transaction_cancel
= db_ntdb_transaction_cancel
;
571 result
->exists
= db_ntdb_exists
;
572 result
->wipe
= db_ntdb_wipe
;
573 result
->id
= db_ntdb_id
;
574 result
->check
= db_ntdb_check
;
575 result
->stored_callback
= NULL
;
576 result
->name
= ntdb_name(db_ntdb
->ntdb
);
577 result
->hash_size
= hash_size
;
581 if (result
!= NULL
) {