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
)
335 static int ntdb_chainlock_timeout(struct ntdb_context
*ntdb
,
337 unsigned int timeout
)
339 union ntdb_attribute locking
;
340 enum NTDB_ERROR ecode
;
342 locking
.base
.attr
= NTDB_ATTRIBUTE_FLOCK
;
343 ecode
= ntdb_get_attribute(ntdb
, &locking
);
344 if (ecode
!= NTDB_SUCCESS
) {
348 /* Replace locking function with our own. */
349 locking
.flock
.data
= &timeout
;
350 locking
.flock
.lock
= timeout_lock
;
352 ecode
= ntdb_set_attribute(ntdb
, &locking
);
353 if (ecode
!= NTDB_SUCCESS
) {
357 ecode
= ntdb_chainlock(ntdb
, key
);
359 ntdb_unset_attribute(ntdb
, NTDB_ATTRIBUTE_FLOCK
);
360 return ecode
== NTDB_SUCCESS
? 0 : -1;
363 static struct db_record
*db_ntdb_fetch_locked_timeout(
364 struct db_context
*db
, TALLOC_CTX
*mem_ctx
, TDB_DATA key
,
365 unsigned int timeout
)
367 struct db_ntdb_ctx
*ctx
= talloc_get_type_abort(db
->private_data
,
370 db_ntdb_log_key("Trying to lock", key
);
371 if (ntdb_chainlock_timeout(ctx
->ntdb
, key
, timeout
) != 0) {
372 DEBUG(3, ("ntdb_chainlock_timeout failed\n"));
375 return db_ntdb_fetch_locked_internal(db
, mem_ctx
, key
);
379 static int db_ntdb_exists(struct db_context
*db
, TDB_DATA key
)
381 struct db_ntdb_ctx
*ctx
= talloc_get_type_abort(
382 db
->private_data
, struct db_ntdb_ctx
);
383 return ntdb_exists(ctx
->ntdb
, key
);
386 static int db_ntdb_wipe(struct db_context
*db
)
388 struct db_ntdb_ctx
*ctx
= talloc_get_type_abort(
389 db
->private_data
, struct db_ntdb_ctx
);
390 if (ntdb_wipe_all(ctx
->ntdb
) != NTDB_SUCCESS
) {
396 static int db_ntdb_check(struct db_context
*db
)
398 struct db_ntdb_ctx
*ctx
= talloc_get_type_abort(
399 db
->private_data
, struct db_ntdb_ctx
);
400 if (ntdb_check(ctx
->ntdb
, NULL
, NULL
) != NTDB_SUCCESS
) {
406 struct db_ntdb_parse_state
{
407 void (*parser
)(TDB_DATA key
, TDB_DATA data
,
413 * ntdb_parse_record expects a parser returning enum NTDB_ERROR,
414 * mixing up ntdb and parser errors. Wrap around that by always
415 * returning NTDB_SUCCESS and have dbwrap_parse_record expect a parser
419 static enum NTDB_ERROR
db_ntdb_parser(NTDB_DATA key
, NTDB_DATA data
,
420 struct db_ntdb_parse_state
*state
)
422 state
->parser(key
, data
, state
->private_data
);
426 static NTSTATUS
db_ntdb_parse(struct db_context
*db
, TDB_DATA key
,
427 void (*parser
)(TDB_DATA key
, TDB_DATA data
,
431 struct db_ntdb_ctx
*ctx
= talloc_get_type_abort(
432 db
->private_data
, struct db_ntdb_ctx
);
433 struct db_ntdb_parse_state state
;
436 state
.parser
= parser
;
437 state
.private_data
= private_data
;
439 err
= ntdb_parse_record(ctx
->ntdb
, key
, db_ntdb_parser
, &state
);
440 return map_nt_error_from_ntdb(err
);
443 struct db_ntdb_traverse_ctx
{
444 struct db_context
*db
;
445 int (*f
)(struct db_record
*rec
, void *private_data
);
449 static int db_ntdb_traverse_func(struct ntdb_context
*ntdb
,
450 NTDB_DATA kbuf
, NTDB_DATA dbuf
,
451 struct db_ntdb_traverse_ctx
*ctx
)
453 struct db_record rec
;
457 rec
.store
= db_ntdb_store
;
458 rec
.delete_rec
= db_ntdb_delete
;
459 rec
.private_data
= ctx
->db
->private_data
;
462 return ctx
->f(&rec
, ctx
->private_data
);
465 static int db_ntdb_traverse(struct db_context
*db
,
466 int (*f
)(struct db_record
*rec
, void *private_data
),
469 struct db_ntdb_ctx
*db_ctx
=
470 talloc_get_type_abort(db
->private_data
, struct db_ntdb_ctx
);
471 struct db_ntdb_traverse_ctx ctx
;
476 ctx
.private_data
= private_data
;
477 ret
= ntdb_traverse(db_ctx
->ntdb
, db_ntdb_traverse_func
, &ctx
);
483 /* Make sure we don't truncate! */
484 if ((int)ret
!= ret
) {
490 static NTSTATUS
db_ntdb_store_deny(struct db_record
*rec
, NTDB_DATA data
, int flag
)
492 return NT_STATUS_MEDIA_WRITE_PROTECTED
;
495 static NTSTATUS
db_ntdb_delete_deny(struct db_record
*rec
)
497 return NT_STATUS_MEDIA_WRITE_PROTECTED
;
500 static int db_ntdb_traverse_read_func(struct ntdb_context
*ntdb
,
501 NTDB_DATA kbuf
, NTDB_DATA dbuf
,
502 struct db_ntdb_traverse_ctx
*ctx
)
504 struct db_record rec
;
508 rec
.store
= db_ntdb_store_deny
;
509 rec
.delete_rec
= db_ntdb_delete_deny
;
510 rec
.private_data
= ctx
->db
->private_data
;
513 return ctx
->f(&rec
, ctx
->private_data
);
516 static int db_ntdb_traverse_read(struct db_context
*db
,
517 int (*f
)(struct db_record
*rec
,
521 struct db_ntdb_ctx
*db_ctx
=
522 talloc_get_type_abort(db
->private_data
, struct db_ntdb_ctx
);
523 struct db_ntdb_traverse_ctx ctx
;
528 ctx
.private_data
= private_data
;
530 /* This is a bit of paranoia to check that f() isn't altering
532 if (ntdb_get_flags(db_ctx
->ntdb
) & NTDB_RDONLY
) {
533 ret
= ntdb_traverse(db_ctx
->ntdb
, db_ntdb_traverse_read_func
,
536 ntdb_add_flag(db_ctx
->ntdb
, NTDB_RDONLY
);
537 ret
= ntdb_traverse(db_ctx
->ntdb
, db_ntdb_traverse_read_func
,
539 ntdb_remove_flag(db_ctx
->ntdb
, NTDB_RDONLY
);
546 /* Make sure we don't truncate! */
547 if ((int)ret
!= ret
) {
553 static int db_ntdb_get_seqnum(struct db_context
*db
)
556 struct db_ntdb_ctx
*db_ctx
=
557 talloc_get_type_abort(db
->private_data
, struct db_ntdb_ctx
);
558 return ntdb_get_seqnum(db_ctx
->ntdb
);
561 static int db_ntdb_transaction_start(struct db_context
*db
)
563 struct db_ntdb_ctx
*db_ctx
=
564 talloc_get_type_abort(db
->private_data
, struct db_ntdb_ctx
);
565 return ntdb_transaction_start(db_ctx
->ntdb
) == NTDB_SUCCESS
? 0 : -1;
568 static NTSTATUS
db_ntdb_transaction_start_nonblock(struct db_context
*db
)
570 union ntdb_attribute orig
;
571 enum NTDB_ERROR ecode
;
572 struct db_ntdb_ctx
*db_ctx
=
573 talloc_get_type_abort(db
->private_data
, struct db_ntdb_ctx
);
575 ecode
= enable_nonblock(db_ctx
->ntdb
, &orig
);
577 ecode
= ntdb_transaction_start(db_ctx
->ntdb
);
578 disable_nonblock(db_ctx
->ntdb
);
580 return map_nt_error_from_ntdb(ecode
);
583 static int db_ntdb_transaction_commit(struct db_context
*db
)
585 struct db_ntdb_ctx
*db_ctx
=
586 talloc_get_type_abort(db
->private_data
, struct db_ntdb_ctx
);
587 return ntdb_transaction_commit(db_ctx
->ntdb
) == NTDB_SUCCESS
? 0 : -1;
590 static int db_ntdb_transaction_cancel(struct db_context
*db
)
592 struct db_ntdb_ctx
*db_ctx
=
593 talloc_get_type_abort(db
->private_data
, struct db_ntdb_ctx
);
594 ntdb_transaction_cancel(db_ctx
->ntdb
);
598 static void db_ntdb_id(struct db_context
*db
, const uint8_t **id
, size_t *idlen
)
600 struct db_ntdb_ctx
*db_ctx
=
601 talloc_get_type_abort(db
->private_data
, struct db_ntdb_ctx
);
602 *id
= (uint8_t *)&db_ctx
->id
;
603 *idlen
= sizeof(db_ctx
->id
);
606 /* Don't ask this to open a .tdb file: dbwrap_local_open will catch that. */
607 struct db_context
*db_open_ntdb(TALLOC_CTX
*mem_ctx
,
608 struct loadparm_context
*lp_ctx
,
609 const char *ntdbname
,
610 int hash_size
, int ntdb_flags
,
611 int open_flags
, mode_t mode
,
612 enum dbwrap_lock_order lock_order
)
614 struct db_context
*result
= NULL
;
615 struct db_ntdb_ctx
*db_ntdb
;
617 union ntdb_attribute hattr
;
619 if ((ntdb_flags
& NTDB_INTERNAL
) && !ntdbname
) {
620 ntdbname
= "unnamed";
623 /* Extra paranoia. */
624 if (strends(ntdbname
, ".tdb")) {
625 DEBUG(0, ("can't try to open %s with ntdb!", ntdbname
));
629 /* We only use this if hsize is non-zero. */
630 hattr
.base
.attr
= NTDB_ATTRIBUTE_HASHSIZE
;
631 hattr
.base
.next
= NULL
;
632 hattr
.hashsize
.size
= hash_size
;
634 result
= talloc_zero(mem_ctx
, struct db_context
);
635 if (result
== NULL
) {
636 DEBUG(0, ("talloc failed\n"));
640 result
->private_data
= db_ntdb
= talloc(result
, struct db_ntdb_ctx
);
641 if (db_ntdb
== NULL
) {
642 DEBUG(0, ("talloc failed\n"));
645 result
->lock_order
= lock_order
;
647 db_ntdb
->ntdb
= ntdb_new(db_ntdb
, ntdbname
, ntdb_flags
,
649 hash_size
? &hattr
: NULL
, lp_ctx
);
650 if (db_ntdb
->ntdb
== NULL
) {
651 DEBUG(3, ("Could not open ntdb %s: %s\n",
652 ntdbname
, strerror(errno
)));
656 ZERO_STRUCT(db_ntdb
->id
);
658 if (fstat(ntdb_fd(db_ntdb
->ntdb
), &st
) == -1) {
659 DEBUG(3, ("fstat failed: %s\n", strerror(errno
)));
662 db_ntdb
->id
.dev
= st
.st_dev
;
663 db_ntdb
->id
.ino
= st
.st_ino
;
665 result
->fetch_locked
= db_ntdb_fetch_locked
;
666 result
->fetch_locked_timeout
= db_ntdb_fetch_locked_timeout
;
667 result
->try_fetch_locked
= db_ntdb_try_fetch_locked
;
668 result
->traverse
= db_ntdb_traverse
;
669 result
->traverse_read
= db_ntdb_traverse_read
;
670 result
->parse_record
= db_ntdb_parse
;
671 result
->get_seqnum
= db_ntdb_get_seqnum
;
672 result
->persistent
= ((ntdb_flags
& NTDB_CLEAR_IF_FIRST
) == 0);
673 result
->transaction_start
= db_ntdb_transaction_start
;
674 result
->transaction_start_nonblock
= db_ntdb_transaction_start_nonblock
;
675 result
->transaction_commit
= db_ntdb_transaction_commit
;
676 result
->transaction_cancel
= db_ntdb_transaction_cancel
;
677 result
->exists
= db_ntdb_exists
;
678 result
->wipe
= db_ntdb_wipe
;
679 result
->id
= db_ntdb_id
;
680 result
->check
= db_ntdb_check
;
681 result
->stored_callback
= NULL
;
682 result
->name
= ntdb_name(db_ntdb
->ntdb
);
683 result
->hash_size
= hash_size
;
687 if (result
!= NULL
) {