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");
54 static NTSTATUS
db_ntdb_store(struct db_record
*rec
, NTDB_DATA data
, int flag
)
56 int ntdb_flag
= tdb_store_flag_to_ntdb(flag
);
57 struct db_ntdb_ctx
*ctx
= talloc_get_type_abort(rec
->private_data
,
61 * This has a bug: We need to replace rec->value for correct
62 * operation, but right now brlock and locking don't use the value
63 * anymore after it was stored.
66 if (ntdb_store(ctx
->ntdb
, rec
->key
, data
, ntdb_flag
) == NTDB_SUCCESS
) {
69 return NT_STATUS_UNSUCCESSFUL
;
72 static NTSTATUS
db_ntdb_delete(struct db_record
*rec
)
75 struct db_ntdb_ctx
*ctx
= talloc_get_type_abort(rec
->private_data
,
78 err
= ntdb_delete(ctx
->ntdb
, rec
->key
);
79 if (err
== NTDB_SUCCESS
) {
83 if (err
== NTDB_ERR_NOEXIST
) {
84 return NT_STATUS_NOT_FOUND
;
87 return NT_STATUS_UNSUCCESSFUL
;
90 static void db_ntdb_log_key(const char *prefix
, NTDB_DATA key
)
95 if (DEBUGLEVEL
< 10) {
99 if (DEBUGLEVEL
== 10) {
101 * Only fully spam at debuglevel > 10
103 len
= MIN(10, key
.dsize
);
105 keystr
= hex_encode_talloc(talloc_tos(), (unsigned char *)(key
.dptr
),
107 DEBUG(10, ("%s key %s\n", prefix
, keystr
));
111 static int db_ntdb_record_destr(struct db_record
* data
)
113 struct db_ntdb_ctx
*ctx
=
114 talloc_get_type_abort(data
->private_data
, struct db_ntdb_ctx
);
116 db_ntdb_log_key("Unlocking", data
->key
);
117 ntdb_chainunlock(ctx
->ntdb
, data
->key
);
121 struct ntdb_fetch_locked_state
{
123 struct db_record
*result
;
126 static enum NTDB_ERROR
db_ntdb_fetchlock_parse(NTDB_DATA key
, NTDB_DATA data
,
127 struct ntdb_fetch_locked_state
*state
)
129 struct db_record
*result
;
131 result
= (struct db_record
*)talloc_size(
133 sizeof(struct db_record
) + key
.dsize
+ data
.dsize
);
135 if (result
== NULL
) {
138 state
->result
= result
;
140 result
->key
.dsize
= key
.dsize
;
141 result
->key
.dptr
= ((uint8_t *)result
) + sizeof(struct db_record
);
142 memcpy(result
->key
.dptr
, key
.dptr
, key
.dsize
);
144 result
->value
.dsize
= data
.dsize
;
146 if (data
.dsize
> 0) {
147 result
->value
.dptr
= result
->key
.dptr
+key
.dsize
;
148 memcpy(result
->value
.dptr
, data
.dptr
, data
.dsize
);
151 result
->value
.dptr
= NULL
;
157 static struct db_record
*db_ntdb_fetch_locked_internal(
158 struct db_context
*db
, TALLOC_CTX
*mem_ctx
, NTDB_DATA key
)
160 struct db_ntdb_ctx
*ctx
= talloc_get_type_abort(db
->private_data
,
162 struct ntdb_fetch_locked_state state
;
164 NTDB_DATA null
= { NULL
, 0 };
166 state
.mem_ctx
= mem_ctx
;
169 err
= ntdb_parse_record(ctx
->ntdb
, key
, db_ntdb_fetchlock_parse
,
171 if (err
!= NTDB_SUCCESS
&& err
!= NTDB_ERR_NOEXIST
) {
172 ntdb_chainunlock(ctx
->ntdb
, key
);
176 if (state
.result
== NULL
) {
177 db_ntdb_fetchlock_parse(key
, null
, &state
);
180 if (state
.result
== NULL
) {
181 ntdb_chainunlock(ctx
->ntdb
, key
);
185 talloc_set_destructor(state
.result
, db_ntdb_record_destr
);
187 state
.result
->private_data
= talloc_reference(state
.result
, ctx
);
188 state
.result
->store
= db_ntdb_store
;
189 state
.result
->delete_rec
= db_ntdb_delete
;
191 DEBUG(10, ("Allocated locked data 0x%p\n", state
.result
));
196 static struct db_record
*db_ntdb_fetch_locked(
197 struct db_context
*db
, TALLOC_CTX
*mem_ctx
, NTDB_DATA key
)
199 struct db_ntdb_ctx
*ctx
= talloc_get_type_abort(db
->private_data
,
202 db_ntdb_log_key("Locking", key
);
203 if (ntdb_chainlock(ctx
->ntdb
, key
) != 0) {
204 DEBUG(3, ("ntdb_chainlock failed\n"));
207 return db_ntdb_fetch_locked_internal(db
, mem_ctx
, key
);
210 /* Proxy which sets waitflag to false so we never block. */
211 static int lock_nonblock(int fd
, int rw
, off_t off
, off_t len
, bool waitflag
,
214 struct ntdb_attribute_flock
*orig
= _orig
;
216 return orig
->lock(fd
, rw
, off
, len
, false, orig
->data
);
219 static enum NTDB_ERROR
enable_nonblock(struct ntdb_context
*ntdb
,
220 union ntdb_attribute
*orig
)
222 union ntdb_attribute locking
;
223 enum NTDB_ERROR ecode
;
225 orig
->base
.attr
= NTDB_ATTRIBUTE_FLOCK
;
226 ecode
= ntdb_get_attribute(ntdb
, orig
);
227 if (ecode
!= NTDB_SUCCESS
) {
231 /* Replace locking function with our own. */
233 locking
.flock
.data
= orig
;
234 locking
.flock
.lock
= lock_nonblock
;
236 return ntdb_set_attribute(ntdb
, &locking
);
239 static void disable_nonblock(struct ntdb_context
*ntdb
)
241 ntdb_unset_attribute(ntdb
, NTDB_ATTRIBUTE_FLOCK
);
244 static enum NTDB_ERROR
ntdb_chainlock_nonblock(struct ntdb_context
*ntdb
,
247 union ntdb_attribute orig
;
248 enum NTDB_ERROR ecode
;
250 ecode
= enable_nonblock(ntdb
, &orig
);
252 ecode
= ntdb_chainlock(ntdb
, key
);
253 disable_nonblock(ntdb
);
258 static struct db_record
*db_ntdb_try_fetch_locked(
259 struct db_context
*db
, TALLOC_CTX
*mem_ctx
, TDB_DATA key
)
261 struct db_ntdb_ctx
*ctx
= talloc_get_type_abort(db
->private_data
,
264 db_ntdb_log_key("Trying to lock", key
);
265 if (ntdb_chainlock_nonblock(ctx
->ntdb
, key
) != 0) {
266 DEBUG(3, ("ntdb_chainlock_nonblock failed\n"));
269 return db_ntdb_fetch_locked_internal(db
, mem_ctx
, key
);
272 static struct flock flock_struct
;
274 /* Return a value which is none of v1, v2 or v3. */
275 static inline short int invalid_value(short int v1
, short int v2
, short int v3
)
277 short int try = (v1
+v2
+v3
)^((v1
+v2
+v3
) << 16);
278 while (try == v1
|| try == v2
|| try == v3
)
283 /* We invalidate in as many ways as we can, so the OS rejects it */
284 static void invalidate_flock_struct(int signum
)
286 flock_struct
.l_type
= invalid_value(F_RDLCK
, F_WRLCK
, F_UNLCK
);
287 flock_struct
.l_whence
= invalid_value(SEEK_SET
, SEEK_CUR
, SEEK_END
);
288 flock_struct
.l_start
= -1;
289 /* A large negative. */
290 flock_struct
.l_len
= (((off_t
)1 << (sizeof(off_t
)*CHAR_BIT
- 1)) + 1);
293 static int timeout_lock(int fd
, int rw
, off_t off
, off_t len
, bool waitflag
,
296 int ret
, saved_errno
;
297 unsigned int timeout
= *(unsigned int *)_timeout
;
299 flock_struct
.l_type
= rw
;
300 flock_struct
.l_whence
= SEEK_SET
;
301 flock_struct
.l_start
= off
;
302 flock_struct
.l_len
= len
;
304 CatchSignal(SIGALRM
, invalidate_flock_struct
);
309 ret
= fcntl(fd
, F_SETLKW
, &flock_struct
);
311 ret
= fcntl(fd
, F_SETLK
, &flock_struct
);
316 /* Not signalled? Something else went wrong. */
317 if (flock_struct
.l_len
== len
) {
318 if (errno
== EAGAIN
|| errno
== EINTR
)
333 static int ntdb_chainlock_timeout(struct ntdb_context
*ntdb
,
335 unsigned int timeout
)
337 union ntdb_attribute locking
;
338 enum NTDB_ERROR ecode
;
340 locking
.base
.attr
= NTDB_ATTRIBUTE_FLOCK
;
341 ecode
= ntdb_get_attribute(ntdb
, &locking
);
342 if (ecode
!= NTDB_SUCCESS
) {
346 /* Replace locking function with our own. */
347 locking
.flock
.data
= &timeout
;
348 locking
.flock
.lock
= timeout_lock
;
350 ecode
= ntdb_set_attribute(ntdb
, &locking
);
351 if (ecode
!= NTDB_SUCCESS
) {
355 ecode
= ntdb_chainlock(ntdb
, key
);
357 ntdb_unset_attribute(ntdb
, NTDB_ATTRIBUTE_FLOCK
);
358 return ecode
== NTDB_SUCCESS
? 0 : -1;
361 static struct db_record
*db_ntdb_fetch_locked_timeout(
362 struct db_context
*db
, TALLOC_CTX
*mem_ctx
, TDB_DATA key
,
363 unsigned int timeout
)
365 struct db_ntdb_ctx
*ctx
= talloc_get_type_abort(db
->private_data
,
368 db_ntdb_log_key("Trying to lock", key
);
369 if (ntdb_chainlock_timeout(ctx
->ntdb
, key
, timeout
) != 0) {
370 DEBUG(3, ("ntdb_chainlock_timeout failed\n"));
373 return db_ntdb_fetch_locked_internal(db
, mem_ctx
, key
);
377 static int db_ntdb_exists(struct db_context
*db
, TDB_DATA key
)
379 struct db_ntdb_ctx
*ctx
= talloc_get_type_abort(
380 db
->private_data
, struct db_ntdb_ctx
);
381 return ntdb_exists(ctx
->ntdb
, key
);
384 static int db_ntdb_wipe(struct db_context
*db
)
386 struct db_ntdb_ctx
*ctx
= talloc_get_type_abort(
387 db
->private_data
, struct db_ntdb_ctx
);
388 if (ntdb_wipe_all(ctx
->ntdb
) != NTDB_SUCCESS
) {
394 static int db_ntdb_check(struct db_context
*db
)
396 struct db_ntdb_ctx
*ctx
= talloc_get_type_abort(
397 db
->private_data
, struct db_ntdb_ctx
);
398 if (ntdb_check(ctx
->ntdb
, NULL
, NULL
) != NTDB_SUCCESS
) {
404 struct db_ntdb_parse_state
{
405 void (*parser
)(TDB_DATA key
, TDB_DATA data
,
411 * ntdb_parse_record expects a parser returning enum NTDB_ERROR,
412 * mixing up ntdb and parser errors. Wrap around that by always
413 * returning NTDB_SUCCESS and have dbwrap_parse_record expect a parser
417 static enum NTDB_ERROR
db_ntdb_parser(NTDB_DATA key
, NTDB_DATA data
,
418 struct db_ntdb_parse_state
*state
)
420 state
->parser(key
, data
, state
->private_data
);
424 static NTSTATUS
db_ntdb_parse(struct db_context
*db
, TDB_DATA key
,
425 void (*parser
)(TDB_DATA key
, TDB_DATA data
,
429 struct db_ntdb_ctx
*ctx
= talloc_get_type_abort(
430 db
->private_data
, struct db_ntdb_ctx
);
431 struct db_ntdb_parse_state state
;
434 state
.parser
= parser
;
435 state
.private_data
= private_data
;
437 err
= ntdb_parse_record(ctx
->ntdb
, key
, db_ntdb_parser
, &state
);
438 return map_nt_error_from_ntdb(err
);
441 struct db_ntdb_traverse_ctx
{
442 struct db_context
*db
;
443 int (*f
)(struct db_record
*rec
, void *private_data
);
447 static int db_ntdb_traverse_func(struct ntdb_context
*ntdb
,
448 NTDB_DATA kbuf
, NTDB_DATA dbuf
,
449 struct db_ntdb_traverse_ctx
*ctx
)
451 struct db_record rec
;
455 rec
.store
= db_ntdb_store
;
456 rec
.delete_rec
= db_ntdb_delete
;
457 rec
.private_data
= ctx
->db
->private_data
;
460 return ctx
->f(&rec
, ctx
->private_data
);
463 static int db_ntdb_traverse(struct db_context
*db
,
464 int (*f
)(struct db_record
*rec
, void *private_data
),
467 struct db_ntdb_ctx
*db_ctx
=
468 talloc_get_type_abort(db
->private_data
, struct db_ntdb_ctx
);
469 struct db_ntdb_traverse_ctx ctx
;
474 ctx
.private_data
= private_data
;
475 ret
= ntdb_traverse(db_ctx
->ntdb
, db_ntdb_traverse_func
, &ctx
);
481 /* Make sure we don't truncate! */
482 if ((int)ret
!= ret
) {
488 static NTSTATUS
db_ntdb_store_deny(struct db_record
*rec
, NTDB_DATA data
, int flag
)
490 return NT_STATUS_MEDIA_WRITE_PROTECTED
;
493 static NTSTATUS
db_ntdb_delete_deny(struct db_record
*rec
)
495 return NT_STATUS_MEDIA_WRITE_PROTECTED
;
498 static int db_ntdb_traverse_read_func(struct ntdb_context
*ntdb
,
499 NTDB_DATA kbuf
, NTDB_DATA dbuf
,
500 struct db_ntdb_traverse_ctx
*ctx
)
502 struct db_record rec
;
506 rec
.store
= db_ntdb_store_deny
;
507 rec
.delete_rec
= db_ntdb_delete_deny
;
508 rec
.private_data
= ctx
->db
->private_data
;
511 return ctx
->f(&rec
, ctx
->private_data
);
514 static int db_ntdb_traverse_read(struct db_context
*db
,
515 int (*f
)(struct db_record
*rec
,
519 struct db_ntdb_ctx
*db_ctx
=
520 talloc_get_type_abort(db
->private_data
, struct db_ntdb_ctx
);
521 struct db_ntdb_traverse_ctx ctx
;
526 ctx
.private_data
= private_data
;
528 /* This is a bit of paranoia to check that f() isn't altering
530 if (ntdb_get_flags(db_ctx
->ntdb
) & NTDB_RDONLY
) {
531 ret
= ntdb_traverse(db_ctx
->ntdb
, db_ntdb_traverse_read_func
,
534 ntdb_add_flag(db_ctx
->ntdb
, NTDB_RDONLY
);
535 ret
= ntdb_traverse(db_ctx
->ntdb
, db_ntdb_traverse_read_func
,
537 ntdb_remove_flag(db_ctx
->ntdb
, NTDB_RDONLY
);
544 /* Make sure we don't truncate! */
545 if ((int)ret
!= ret
) {
551 static int db_ntdb_get_seqnum(struct db_context
*db
)
554 struct db_ntdb_ctx
*db_ctx
=
555 talloc_get_type_abort(db
->private_data
, struct db_ntdb_ctx
);
556 return ntdb_get_seqnum(db_ctx
->ntdb
);
559 static int db_ntdb_transaction_start(struct db_context
*db
)
561 struct db_ntdb_ctx
*db_ctx
=
562 talloc_get_type_abort(db
->private_data
, struct db_ntdb_ctx
);
563 return ntdb_transaction_start(db_ctx
->ntdb
) == NTDB_SUCCESS
? 0 : -1;
566 static NTSTATUS
db_ntdb_transaction_start_nonblock(struct db_context
*db
)
568 union ntdb_attribute orig
;
569 enum NTDB_ERROR ecode
;
570 struct db_ntdb_ctx
*db_ctx
=
571 talloc_get_type_abort(db
->private_data
, struct db_ntdb_ctx
);
573 ecode
= enable_nonblock(db_ctx
->ntdb
, &orig
);
575 ecode
= ntdb_transaction_start(db_ctx
->ntdb
);
576 disable_nonblock(db_ctx
->ntdb
);
578 return map_nt_error_from_ntdb(ecode
);
581 static int db_ntdb_transaction_commit(struct db_context
*db
)
583 struct db_ntdb_ctx
*db_ctx
=
584 talloc_get_type_abort(db
->private_data
, struct db_ntdb_ctx
);
585 return ntdb_transaction_commit(db_ctx
->ntdb
) == NTDB_SUCCESS
? 0 : -1;
588 static int db_ntdb_transaction_cancel(struct db_context
*db
)
590 struct db_ntdb_ctx
*db_ctx
=
591 talloc_get_type_abort(db
->private_data
, struct db_ntdb_ctx
);
592 ntdb_transaction_cancel(db_ctx
->ntdb
);
596 static void db_ntdb_id(struct db_context
*db
, const uint8_t **id
, size_t *idlen
)
598 struct db_ntdb_ctx
*db_ctx
=
599 talloc_get_type_abort(db
->private_data
, struct db_ntdb_ctx
);
600 *id
= (uint8_t *)&db_ctx
->id
;
601 *idlen
= sizeof(db_ctx
->id
);
604 /* Don't ask this to open a .tdb file: dbwrap_local_open will catch that. */
605 struct db_context
*db_open_ntdb(TALLOC_CTX
*mem_ctx
,
606 struct loadparm_context
*lp_ctx
,
607 const char *ntdbname
,
608 int hash_size
, int ntdb_flags
,
609 int open_flags
, mode_t mode
,
610 enum dbwrap_lock_order lock_order
)
612 struct db_context
*result
= NULL
;
613 struct db_ntdb_ctx
*db_ntdb
;
615 union ntdb_attribute hattr
;
617 if ((ntdb_flags
& NTDB_INTERNAL
) && !ntdbname
) {
618 ntdbname
= "unnamed";
621 /* Extra paranoia. */
622 if (strends(ntdbname
, ".tdb")) {
623 DEBUG(0, ("can't try to open %s with ntdb!", ntdbname
));
627 /* We only use this if hsize is non-zero. */
628 hattr
.base
.attr
= NTDB_ATTRIBUTE_HASHSIZE
;
629 hattr
.base
.next
= NULL
;
630 hattr
.hashsize
.size
= hash_size
;
632 result
= talloc_zero(mem_ctx
, struct db_context
);
633 if (result
== NULL
) {
634 DEBUG(0, ("talloc failed\n"));
638 result
->private_data
= db_ntdb
= talloc(result
, struct db_ntdb_ctx
);
639 if (db_ntdb
== NULL
) {
640 DEBUG(0, ("talloc failed\n"));
643 result
->lock_order
= lock_order
;
645 db_ntdb
->ntdb
= ntdb_new(db_ntdb
, ntdbname
, ntdb_flags
,
647 hash_size
? &hattr
: NULL
, lp_ctx
);
648 if (db_ntdb
->ntdb
== NULL
) {
649 DEBUG(3, ("Could not open ntdb %s: %s\n",
650 ntdbname
, strerror(errno
)));
654 ZERO_STRUCT(db_ntdb
->id
);
656 if (fstat(ntdb_fd(db_ntdb
->ntdb
), &st
) == -1) {
657 DEBUG(3, ("fstat failed: %s\n", strerror(errno
)));
660 db_ntdb
->id
.dev
= st
.st_dev
;
661 db_ntdb
->id
.ino
= st
.st_ino
;
663 result
->fetch_locked
= db_ntdb_fetch_locked
;
664 result
->fetch_locked_timeout
= db_ntdb_fetch_locked_timeout
;
665 result
->try_fetch_locked
= db_ntdb_try_fetch_locked
;
666 result
->traverse
= db_ntdb_traverse
;
667 result
->traverse_read
= db_ntdb_traverse_read
;
668 result
->parse_record
= db_ntdb_parse
;
669 result
->get_seqnum
= db_ntdb_get_seqnum
;
670 result
->persistent
= ((ntdb_flags
& NTDB_CLEAR_IF_FIRST
) == 0);
671 result
->transaction_start
= db_ntdb_transaction_start
;
672 result
->transaction_start_nonblock
= db_ntdb_transaction_start_nonblock
;
673 result
->transaction_commit
= db_ntdb_transaction_commit
;
674 result
->transaction_cancel
= db_ntdb_transaction_cancel
;
675 result
->exists
= db_ntdb_exists
;
676 result
->wipe
= db_ntdb_wipe
;
677 result
->id
= db_ntdb_id
;
678 result
->check
= db_ntdb_check
;
679 result
->stored_callback
= NULL
;
680 result
->name
= ntdb_name(db_ntdb
->ntdb
);
681 result
->hash_size
= hash_size
;
685 if (result
!= NULL
) {