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)) {