2 Unix SMB/CIFS implementation.
3 Utility functions for the dbwrap API
4 Copyright (C) Volker Lendecke 2007
5 Copyright (C) Michael Adam 2009
6 Copyright (C) Jim McDonough <jmcd@us.ibm.com> 2006
8 Major code contributions from Aleksey Fedoseev (fedoseev@ru.ibm.com)
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
27 #include "lib/util/util_tdb.h"
29 struct dbwrap_fetch_int32_state
{
34 static void dbwrap_fetch_int32_parser(TDB_DATA key
, TDB_DATA data
,
37 struct dbwrap_fetch_int32_state
*state
=
38 (struct dbwrap_fetch_int32_state
*)private_data
;
40 if (data
.dsize
!= sizeof(state
->result
)) {
41 state
->status
= NT_STATUS_INTERNAL_DB_CORRUPTION
;
44 state
->result
= IVAL(data
.dptr
, 0);
45 state
->status
= NT_STATUS_OK
;
48 NTSTATUS
dbwrap_fetch_int32(struct db_context
*db
, TDB_DATA key
,
51 struct dbwrap_fetch_int32_state state
;
55 return NT_STATUS_INVALID_PARAMETER
;
58 state
.status
= NT_STATUS_INTERNAL_ERROR
;
60 status
= dbwrap_parse_record(db
, key
, dbwrap_fetch_int32_parser
, &state
);
61 if (!NT_STATUS_IS_OK(status
)) {
65 if (NT_STATUS_IS_OK(state
.status
)) {
66 *result
= state
.result
;
71 NTSTATUS
dbwrap_fetch_int32_bystring(struct db_context
*db
, const char *keystr
,
74 return dbwrap_fetch_int32(db
, string_term_tdb_data(keystr
), result
);
77 NTSTATUS
dbwrap_store_int32_bystring(struct db_context
*db
, const char *keystr
,
80 uint8_t v_store
[sizeof(int32_t)];
81 TDB_DATA data
= { .dptr
= v_store
, .dsize
= sizeof(v_store
) };
86 status
= dbwrap_store(db
, string_term_tdb_data(keystr
), data
,
91 struct dbwrap_fetch_uint32_state
{
96 static void dbwrap_fetch_uint32_parser(TDB_DATA key
, TDB_DATA data
,
99 struct dbwrap_fetch_uint32_state
*state
=
100 (struct dbwrap_fetch_uint32_state
*)private_data
;
102 if (data
.dsize
!= sizeof(state
->result
)) {
103 state
->status
= NT_STATUS_INTERNAL_DB_CORRUPTION
;
106 state
->result
= IVAL(data
.dptr
, 0);
107 state
->status
= NT_STATUS_OK
;
110 NTSTATUS
dbwrap_fetch_uint32_bystring(struct db_context
*db
,
111 const char *keystr
, uint32_t *val
)
113 struct dbwrap_fetch_uint32_state state
;
117 return NT_STATUS_INVALID_PARAMETER
;
120 state
.status
= NT_STATUS_INTERNAL_ERROR
;
122 status
= dbwrap_parse_record(db
, string_term_tdb_data(keystr
),
123 dbwrap_fetch_uint32_parser
, &state
);
124 if (!NT_STATUS_IS_OK(status
)) {
127 if (NT_STATUS_IS_OK(state
.status
)) {
133 NTSTATUS
dbwrap_store_uint32_bystring(struct db_context
*db
,
134 const char *keystr
, uint32_t v
)
136 uint8_t v_store
[sizeof(uint32_t)];
137 TDB_DATA data
= { .dptr
= v_store
, .dsize
= sizeof(v_store
) };
140 SIVAL(v_store
, 0, v
);
142 status
= dbwrap_store(db
, string_term_tdb_data(keystr
), data
,
148 * Atomic unsigned integer change (addition):
150 * if value does not exist yet in the db, use *oldval as initial old value.
151 * return old value in *oldval.
152 * store *oldval + change_val to db.
155 struct dbwrap_change_uint32_atomic_context
{
162 static void dbwrap_change_uint32_atomic_action_fn(struct db_record
*rec
,
166 struct dbwrap_change_uint32_atomic_context
*state
= private_data
;
170 .dsize
= sizeof(v_store
),
172 uint32_t val
= UINT32_MAX
;
174 if (value
.dptr
== NULL
) {
175 val
= *(state
->oldval
);
176 } else if (value
.dsize
== sizeof(val
)) {
177 val
= PULL_LE_U32(value
.dptr
, 0);
178 *(state
->oldval
) = val
;
180 state
->status
= NT_STATUS_UNSUCCESSFUL
;
184 val
+= state
->change_val
;
185 PUSH_LE_U32(v_store
, 0, val
);
187 state
->status
= dbwrap_record_store(rec
, data
, TDB_REPLACE
);
190 static NTSTATUS
dbwrap_change_uint32_atomic_action(struct db_context
*db
,
193 struct dbwrap_change_uint32_atomic_context
*state
= private_data
;
196 status
= dbwrap_do_locked(db
,
197 string_term_tdb_data(state
->keystr
),
198 dbwrap_change_uint32_atomic_action_fn
,
200 if (!NT_STATUS_IS_OK(status
)) {
201 DBG_DEBUG("dbwrap_do_locked() failed: %s\n",
205 if (!NT_STATUS_IS_OK(state
->status
)) {
206 DBG_DEBUG("dbwrap_change_uint32_atomic_action_fn() "
214 NTSTATUS
dbwrap_change_uint32_atomic_bystring(struct db_context
*db
,
220 struct dbwrap_change_uint32_atomic_context state
;
222 state
.keystr
= keystr
;
223 state
.oldval
= oldval
;
224 state
.change_val
= change_val
;
226 ret
= dbwrap_change_uint32_atomic_action(db
, &state
);
231 NTSTATUS
dbwrap_trans_change_uint32_atomic_bystring(struct db_context
*db
,
237 struct dbwrap_change_uint32_atomic_context state
;
239 state
.keystr
= keystr
;
240 state
.oldval
= oldval
;
241 state
.change_val
= change_val
;
243 ret
= dbwrap_trans_do(db
, dbwrap_change_uint32_atomic_action
, &state
);
249 * Atomic integer change (addition):
251 * if value does not exist yet in the db, use *oldval as initial old value.
252 * return old value in *oldval.
253 * store *oldval + change_val to db.
256 struct dbwrap_change_int32_atomic_context
{
263 static void dbwrap_change_int32_atomic_action_fn(struct db_record
*rec
,
267 struct dbwrap_change_int32_atomic_context
*state
= private_data
;
271 .dsize
= sizeof(v_store
),
275 if (value
.dptr
== NULL
) {
276 val
= *(state
->oldval
);
277 } else if (value
.dsize
== sizeof(val
)) {
278 val
= PULL_LE_U32(value
.dptr
, 0);
279 *(state
->oldval
) = val
;
281 state
->status
= NT_STATUS_UNSUCCESSFUL
;
285 val
+= state
->change_val
;
286 PUSH_LE_U32(v_store
, 0, val
);
288 state
->status
= dbwrap_record_store(rec
, data
, TDB_REPLACE
);
291 static NTSTATUS
dbwrap_change_int32_atomic_action(struct db_context
*db
,
294 struct dbwrap_change_int32_atomic_context
*state
= private_data
;
297 status
= dbwrap_do_locked(db
,
299 dbwrap_change_int32_atomic_action_fn
,
301 if (!NT_STATUS_IS_OK(status
)) {
302 DBG_DEBUG("dbwrap_do_locked() failed: %s\n",
306 if (!NT_STATUS_IS_OK(state
->status
)) {
307 DBG_DEBUG("dbwrap_change_int32_atomic_action_fn() "
315 NTSTATUS
dbwrap_change_int32_atomic(struct db_context
*db
,
321 struct dbwrap_change_int32_atomic_context state
;
324 state
.oldval
= oldval
;
325 state
.change_val
= change_val
;
327 ret
= dbwrap_change_int32_atomic_action(db
, &state
);
332 NTSTATUS
dbwrap_change_int32_atomic_bystring(struct db_context
*db
,
337 return dbwrap_change_int32_atomic(db
, string_term_tdb_data(keystr
),
341 NTSTATUS
dbwrap_trans_change_int32_atomic_bystring(struct db_context
*db
,
347 struct dbwrap_change_int32_atomic_context state
;
349 state
.key
= string_term_tdb_data(keystr
);
350 state
.oldval
= oldval
;
351 state
.change_val
= change_val
;
353 ret
= dbwrap_trans_do(db
, dbwrap_change_int32_atomic_action
, &state
);
358 struct dbwrap_store_context
{
364 static NTSTATUS
dbwrap_store_action(struct db_context
*db
, void *private_data
)
367 struct dbwrap_store_context
*store_ctx
;
369 store_ctx
= (struct dbwrap_store_context
*)private_data
;
371 status
= dbwrap_store(db
, *(store_ctx
->key
), *(store_ctx
->dbuf
),
373 if (!NT_STATUS_IS_OK(status
)) {
374 DEBUG(5, ("store returned %s\n", nt_errstr(status
)));
380 NTSTATUS
dbwrap_trans_store(struct db_context
*db
, TDB_DATA key
, TDB_DATA dbuf
,
384 struct dbwrap_store_context store_ctx
;
386 store_ctx
.key
= &key
;
387 store_ctx
.dbuf
= &dbuf
;
388 store_ctx
.flag
= flag
;
390 status
= dbwrap_trans_do(db
, dbwrap_store_action
, &store_ctx
);
395 static NTSTATUS
dbwrap_delete_action(struct db_context
* db
, void *private_data
)
398 TDB_DATA
*key
= (TDB_DATA
*)private_data
;
400 status
= dbwrap_delete(db
, *key
);
401 if (!NT_STATUS_IS_OK(status
)) {
402 DBG_INFO("dbwrap_record_delete returned %s\n",
408 NTSTATUS
dbwrap_trans_delete(struct db_context
*db
, TDB_DATA key
)
412 status
= dbwrap_trans_do(db
, dbwrap_delete_action
, &key
);
417 NTSTATUS
dbwrap_trans_store_int32_bystring(struct db_context
*db
,
423 SIVAL(&v_store
, 0, v
);
425 return dbwrap_trans_store(db
, string_term_tdb_data(keystr
),
426 make_tdb_data((const uint8_t *)&v_store
,
431 NTSTATUS
dbwrap_trans_store_uint32_bystring(struct db_context
*db
,
437 SIVAL(&v_store
, 0, v
);
439 return dbwrap_trans_store(db
, string_term_tdb_data(keystr
),
440 make_tdb_data((const uint8_t *)&v_store
,
445 NTSTATUS
dbwrap_trans_store_bystring(struct db_context
*db
, const char *key
,
446 TDB_DATA data
, int flags
)
448 return dbwrap_trans_store(db
, string_term_tdb_data(key
), data
, flags
);
451 NTSTATUS
dbwrap_trans_delete_bystring(struct db_context
*db
, const char *key
)
453 return dbwrap_trans_delete(db
, string_term_tdb_data(key
));
457 * Wrap db action(s) into a transaction.
459 NTSTATUS
dbwrap_trans_do(struct db_context
*db
,
460 NTSTATUS (*action
)(struct db_context
*, void *),
466 res
= dbwrap_transaction_start(db
);
468 DEBUG(5, ("transaction_start failed\n"));
469 return NT_STATUS_INTERNAL_DB_CORRUPTION
;
472 status
= action(db
, private_data
);
473 if (!NT_STATUS_IS_OK(status
)) {
474 if (dbwrap_transaction_cancel(db
) != 0) {
475 smb_panic("Cancelling transaction failed");
480 res
= dbwrap_transaction_commit(db
);
485 DEBUG(2, ("transaction_commit failed\n"));
486 return NT_STATUS_INTERNAL_DB_CORRUPTION
;
489 struct dbwrap_trans_traverse_action_ctx
{
490 int (*f
)(struct db_record
* rec
, void* private_data
);
495 static NTSTATUS
dbwrap_trans_traverse_action(struct db_context
* db
, void* private_data
)
497 struct dbwrap_trans_traverse_action_ctx
* ctx
=
498 (struct dbwrap_trans_traverse_action_ctx
*)private_data
;
500 NTSTATUS status
= dbwrap_traverse(db
, ctx
->f
, ctx
->private_data
, NULL
);
505 NTSTATUS
dbwrap_trans_traverse(struct db_context
*db
,
506 int (*f
)(struct db_record
*, void*),
509 struct dbwrap_trans_traverse_action_ctx ctx
= {
511 .private_data
= private_data
,
513 return dbwrap_trans_do(db
, dbwrap_trans_traverse_action
, &ctx
);
516 NTSTATUS
dbwrap_purge(struct db_context
*db
, TDB_DATA key
)
520 status
= dbwrap_delete(db
, key
);
521 if (NT_STATUS_EQUAL(status
, NT_STATUS_NOT_FOUND
)) {
522 status
= NT_STATUS_OK
;
528 NTSTATUS
dbwrap_purge_bystring(struct db_context
*db
, const char *key
)
530 return dbwrap_purge(db
, string_term_tdb_data(key
));
533 NTSTATUS
dbwrap_delete_bystring(struct db_context
*db
, const char *key
)
535 return dbwrap_delete(db
, string_term_tdb_data(key
));
538 NTSTATUS
dbwrap_store_bystring(struct db_context
*db
, const char *key
,
539 TDB_DATA data
, int flags
)
541 return dbwrap_store(db
, string_term_tdb_data(key
), data
, flags
);
544 NTSTATUS
dbwrap_fetch_bystring(struct db_context
*db
, TALLOC_CTX
*mem_ctx
,
545 const char *key
, TDB_DATA
*value
)
547 return dbwrap_fetch(db
, mem_ctx
, string_term_tdb_data(key
), value
);
552 NTSTATUS
dbwrap_delete_bystring_upper(struct db_context
*db
, const char *key
)
557 key_upper
= talloc_strdup_upper(talloc_tos(), key
);
558 if (key_upper
== NULL
) {
559 return NT_STATUS_NO_MEMORY
;
562 status
= dbwrap_delete_bystring(db
, key_upper
);
564 talloc_free(key_upper
);
568 NTSTATUS
dbwrap_store_bystring_upper(struct db_context
*db
, const char *key
,
569 TDB_DATA data
, int flags
)
574 key_upper
= talloc_strdup_upper(talloc_tos(), key
);
575 if (key_upper
== NULL
) {
576 return NT_STATUS_NO_MEMORY
;
579 status
= dbwrap_store_bystring(db
, key_upper
, data
, flags
);
581 talloc_free(key_upper
);
585 NTSTATUS
dbwrap_fetch_bystring_upper(struct db_context
*db
, TALLOC_CTX
*mem_ctx
,
586 const char *key
, TDB_DATA
*value
)
591 key_upper
= talloc_strdup_upper(talloc_tos(), key
);
592 if (key_upper
== NULL
) {
593 return NT_STATUS_NO_MEMORY
;
596 status
= dbwrap_fetch_bystring(db
, mem_ctx
, key_upper
, value
);
598 talloc_free(key_upper
);
602 struct dbwrap_marshall_state
{
608 static int dbwrap_marshall_fn(struct db_record
*rec
, void *private_data
)
610 struct dbwrap_marshall_state
*state
= private_data
;
614 key
= dbwrap_record_get_key(rec
);
615 value
= dbwrap_record_get_value(rec
);
617 new_dbsize
= state
->dbsize
;
618 new_dbsize
+= 8 + key
.dsize
;
619 new_dbsize
+= 8 + value
.dsize
;
621 if (new_dbsize
<= state
->bufsize
) {
622 uint8_t *p
= state
->buf
+ state
->dbsize
;
624 SBVAL(p
, 0, key
.dsize
);
626 memcpy(p
, key
.dptr
, key
.dsize
);
629 SBVAL(p
, 0, value
.dsize
);
631 memcpy(p
, value
.dptr
, value
.dsize
);
633 state
->dbsize
= new_dbsize
;
637 size_t dbwrap_marshall(struct db_context
*db
, uint8_t *buf
, size_t bufsize
)
639 struct dbwrap_marshall_state state
;
641 state
.bufsize
= bufsize
;
645 dbwrap_traverse_read(db
, dbwrap_marshall_fn
, &state
, NULL
);
650 static ssize_t
dbwrap_unmarshall_get_data(const uint8_t *buf
, size_t buflen
,
651 size_t ofs
, TDB_DATA
*pdata
)
663 space
= buflen
- ofs
;
678 *pdata
= (TDB_DATA
) { .dptr
= discard_const_p(uint8_t, p
),
683 NTSTATUS
dbwrap_parse_marshall_buf(const uint8_t *buf
, size_t buflen
,
684 bool (*fn
)(TDB_DATA key
, TDB_DATA value
,
695 len
= dbwrap_unmarshall_get_data(buf
, buflen
, ofs
, &key
);
700 return NT_STATUS_INVALID_PARAMETER
;
704 len
= dbwrap_unmarshall_get_data(buf
, buflen
, ofs
, &value
);
709 return NT_STATUS_INVALID_PARAMETER
;
713 ok
= fn(key
, value
, private_data
);
722 struct dbwrap_unmarshall_state
{
723 struct db_context
*db
;
727 static bool dbwrap_unmarshall_fn(TDB_DATA key
, TDB_DATA value
,
730 struct dbwrap_unmarshall_state
*state
= private_data
;
733 status
= dbwrap_store(state
->db
, key
, value
, 0);
734 if (!NT_STATUS_IS_OK(status
)) {
735 DBG_DEBUG("dbwrap_record_store failed: %s\n",
744 NTSTATUS
dbwrap_unmarshall(struct db_context
*db
, const uint8_t *buf
,
747 struct dbwrap_unmarshall_state state
= { .db
= db
};
750 status
= dbwrap_parse_marshall_buf(buf
, buflen
,
751 dbwrap_unmarshall_fn
, &state
);
752 if (!NT_STATUS_IS_OK(status
)) {