diff options
Diffstat (limited to 'lib/dbwrap')
-rw-r--r-- | lib/dbwrap/dbwrap.c | 701 | ||||
-rw-r--r-- | lib/dbwrap/dbwrap.h | 239 | ||||
-rw-r--r-- | lib/dbwrap/dbwrap_local_open.c | 46 | ||||
-rw-r--r-- | lib/dbwrap/dbwrap_private.h | 93 | ||||
-rw-r--r-- | lib/dbwrap/dbwrap_rbt.c | 586 | ||||
-rw-r--r-- | lib/dbwrap/dbwrap_rbt.h | 29 | ||||
-rw-r--r-- | lib/dbwrap/dbwrap_tdb.c | 518 | ||||
-rw-r--r-- | lib/dbwrap/dbwrap_tdb.h | 35 | ||||
-rw-r--r-- | lib/dbwrap/dbwrap_util.c | 737 | ||||
-rw-r--r-- | lib/dbwrap/wscript_build | 8 |
10 files changed, 2992 insertions, 0 deletions
diff --git a/lib/dbwrap/dbwrap.c b/lib/dbwrap/dbwrap.c new file mode 100644 index 0000000..7555efa --- /dev/null +++ b/lib/dbwrap/dbwrap.c @@ -0,0 +1,701 @@ +/* + Unix SMB/CIFS implementation. + Database interface wrapper + Copyright (C) Jim McDonough <jmcd@us.ibm.com> 2006 + + Major code contributions from Aleksey Fedoseev (fedoseev@ru.ibm.com) + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. +*/ + +#include "replace.h" +#include "lib/util/debug.h" +#include "lib/util/fault.h" +#include "lib/util/talloc_stack.h" +#include "dbwrap/dbwrap.h" +#include "dbwrap/dbwrap_private.h" +#include "lib/util/util_tdb.h" +#include "lib/util/tevent_ntstatus.h" + +/* + * Fall back using fetch if no genuine exists operation is provided + */ + +static int dbwrap_fallback_exists(struct db_context *db, TDB_DATA key) +{ + NTSTATUS status = dbwrap_parse_record(db, key, NULL, NULL); + return NT_STATUS_IS_OK(status) ? 1 : 0; +} + +static int delete_record(struct db_record *rec, void *data) +{ + NTSTATUS status = dbwrap_record_delete(rec); + return NT_STATUS_IS_OK(status) ? 0 : -1; +} + +/* + * Fallback wipe implementation using traverse and delete if no genuine + * wipe operation is provided + */ +static int dbwrap_fallback_wipe(struct db_context *db) +{ + NTSTATUS status = dbwrap_trans_traverse(db, delete_record, NULL); + return NT_STATUS_IS_OK(status) ? 0 : -1; +} + +static int do_nothing(struct db_record *rec, void *unused) +{ + return 0; +} + +/* + * Fallback check operation: just traverse. + */ +static int dbwrap_fallback_check(struct db_context *db) +{ + NTSTATUS status = dbwrap_traverse_read(db, do_nothing, NULL, NULL); + return NT_STATUS_IS_OK(status) ? 0 : -1; +} + +/* + * Wrapper functions for the backend methods + */ + +TDB_DATA dbwrap_record_get_key(const struct db_record *rec) +{ + return rec->key; +} + +TDB_DATA dbwrap_record_get_value(const struct db_record *rec) +{ + SMB_ASSERT(rec->value_valid); + return rec->value; +} + +NTSTATUS dbwrap_record_storev(struct db_record *rec, + const TDB_DATA *dbufs, int num_dbufs, int flags) +{ + NTSTATUS status; + + /* + * Invalidate before rec->storev() is called, give + * rec->storev() the chance to re-validate rec->value. + */ + rec->value_valid = false; + + status = rec->storev(rec, dbufs, num_dbufs, flags); + if (!NT_STATUS_IS_OK(status)) { + return status; + } + return NT_STATUS_OK; +} + +NTSTATUS dbwrap_record_store(struct db_record *rec, TDB_DATA data, int flags) +{ + return dbwrap_record_storev(rec, &data, 1, flags); +} + +NTSTATUS dbwrap_record_delete(struct db_record *rec) +{ + NTSTATUS status; + + status = rec->delete_rec(rec); + if (!NT_STATUS_IS_OK(status)) { + return status; + } + + rec->value = tdb_null; + + return NT_STATUS_OK; +} + +const char *locked_dbs[DBWRAP_LOCK_ORDER_MAX]; + +static void debug_lock_order(int level) +{ + int i; + DEBUG(level, ("lock order: ")); + for (i=0; i<DBWRAP_LOCK_ORDER_MAX; i++) { + DEBUGADD(level, + (" %d:%s", + i + 1, + locked_dbs[i] ? locked_dbs[i] : "<none>")); + } + DEBUGADD(level, ("\n")); +} + +void dbwrap_lock_order_lock(const char *db_name, + enum dbwrap_lock_order lock_order) +{ + int idx; + + DBG_INFO("check lock order %d for %s\n", + (int)lock_order, + db_name); + + if (!DBWRAP_LOCK_ORDER_VALID(lock_order)) { + DBG_ERR("Invalid lock order %d of %s\n", + lock_order, + db_name); + smb_panic("lock order violation"); + } + + for (idx=lock_order-1; idx<DBWRAP_LOCK_ORDER_MAX; idx++) { + if (locked_dbs[idx] != NULL) { + DBG_ERR("Lock order violation: Trying %s at %d while " + "%s at %d is locked\n", + db_name, + (int)lock_order, + locked_dbs[idx], + idx + 1); + debug_lock_order(0); + smb_panic("lock order violation"); + } + } + + locked_dbs[lock_order-1] = db_name; + + debug_lock_order(10); +} + +void dbwrap_lock_order_unlock(const char *db_name, + enum dbwrap_lock_order lock_order) +{ + DBG_INFO("release lock order %d for %s\n", + (int)lock_order, + db_name); + + if (!DBWRAP_LOCK_ORDER_VALID(lock_order)) { + DBG_ERR("Invalid lock order %d of %s\n", + lock_order, + db_name); + smb_panic("lock order violation"); + } + + if (locked_dbs[lock_order-1] == NULL) { + DBG_ERR("db %s at order %d unlocked\n", + db_name, + (int)lock_order); + smb_panic("lock order violation"); + } + + if (locked_dbs[lock_order-1] != db_name) { + DBG_ERR("locked db at lock order %d is %s, expected %s\n", + (int)lock_order, + locked_dbs[lock_order-1], + db_name); + smb_panic("lock order violation"); + } + + locked_dbs[lock_order-1] = NULL; +} + +struct dbwrap_lock_order_state { + struct db_context *db; +}; + +static int dbwrap_lock_order_state_destructor( + struct dbwrap_lock_order_state *s) +{ + struct db_context *db = s->db; + dbwrap_lock_order_unlock(db->name, db->lock_order); + return 0; +} + +static struct dbwrap_lock_order_state *dbwrap_check_lock_order( + struct db_context *db, TALLOC_CTX *mem_ctx) +{ + struct dbwrap_lock_order_state *state; + + state = talloc(mem_ctx, struct dbwrap_lock_order_state); + if (state == NULL) { + DBG_WARNING("talloc failed\n"); + return NULL; + } + state->db = db; + + dbwrap_lock_order_lock(db->name, db->lock_order); + talloc_set_destructor(state, dbwrap_lock_order_state_destructor); + + return state; +} + +static struct db_record *dbwrap_fetch_locked_internal( + struct db_context *db, TALLOC_CTX *mem_ctx, TDB_DATA key, + struct db_record *(*db_fn)(struct db_context *db, TALLOC_CTX *mem_ctx, + TDB_DATA key)) +{ + struct db_record *rec; + struct dbwrap_lock_order_state *lock_order = NULL; + + if (db->lock_order != DBWRAP_LOCK_ORDER_NONE) { + lock_order = dbwrap_check_lock_order(db, mem_ctx); + if (lock_order == NULL) { + return NULL; + } + } + rec = db_fn(db, mem_ctx, key); + if (rec == NULL) { + TALLOC_FREE(lock_order); + return NULL; + } + (void)talloc_steal(rec, lock_order); + rec->db = db; + return rec; +} + +struct db_record *dbwrap_fetch_locked(struct db_context *db, + TALLOC_CTX *mem_ctx, + TDB_DATA key) +{ + return dbwrap_fetch_locked_internal(db, mem_ctx, key, + db->fetch_locked); +} + +struct db_context *dbwrap_record_get_db(struct db_record *rec) +{ + return rec->db; +} + +struct dbwrap_fetch_state { + TALLOC_CTX *mem_ctx; + TDB_DATA data; +}; + +static void dbwrap_fetch_parser(TDB_DATA key, TDB_DATA data, + void *private_data) +{ + struct dbwrap_fetch_state *state = + (struct dbwrap_fetch_state *)private_data; + + state->data.dsize = data.dsize; + state->data.dptr = (uint8_t *)talloc_memdup(state->mem_ctx, data.dptr, + data.dsize); +} + +NTSTATUS dbwrap_fetch(struct db_context *db, TALLOC_CTX *mem_ctx, + TDB_DATA key, TDB_DATA *value) +{ + struct dbwrap_fetch_state state; + NTSTATUS status; + + if (value == NULL) { + return NT_STATUS_INVALID_PARAMETER; + } + + state.mem_ctx = mem_ctx; + + status = dbwrap_parse_record(db, key, dbwrap_fetch_parser, &state); + if (!NT_STATUS_IS_OK(status)) { + return status; + } + if ((state.data.dsize != 0) && (state.data.dptr == NULL)) { + return NT_STATUS_NO_MEMORY; + } + *value = state.data; + return NT_STATUS_OK; +} + +bool dbwrap_exists(struct db_context *db, TDB_DATA key) +{ + int result; + if (db->exists != NULL) { + result = db->exists(db, key); + } else { + result = dbwrap_fallback_exists(db,key); + } + return (result == 1); +} + +struct dbwrap_store_state { + TDB_DATA data; + int flags; + NTSTATUS status; +}; + +static void dbwrap_store_fn( + struct db_record *rec, + TDB_DATA value, + void *private_data) +{ + struct dbwrap_store_state *state = private_data; + state->status = dbwrap_record_store(rec, state->data, state->flags); +} + +NTSTATUS dbwrap_store(struct db_context *db, TDB_DATA key, + TDB_DATA data, int flags) +{ + struct dbwrap_store_state state = { .data = data, .flags = flags }; + NTSTATUS status; + + status = dbwrap_do_locked(db, key, dbwrap_store_fn, &state); + if (!NT_STATUS_IS_OK(status)) { + return status; + } + + return state.status; +} + +struct dbwrap_delete_state { + NTSTATUS status; +}; + +static void dbwrap_delete_fn( + struct db_record *rec, + TDB_DATA value, + void *private_data) +{ + struct dbwrap_delete_state *state = private_data; + state->status = dbwrap_record_delete(rec); +} + +NTSTATUS dbwrap_delete(struct db_context *db, TDB_DATA key) +{ + struct dbwrap_delete_state state = { .status = NT_STATUS_NOT_FOUND }; + NTSTATUS status; + + status = dbwrap_do_locked(db, key, dbwrap_delete_fn, &state); + if (!NT_STATUS_IS_OK(status)) { + return status; + } + + return state.status; +} + +NTSTATUS dbwrap_traverse(struct db_context *db, + int (*f)(struct db_record*, void*), + void *private_data, + int *count) +{ + int ret = db->traverse(db, f, private_data); + + if (ret < 0) { + return NT_STATUS_INTERNAL_DB_CORRUPTION; + } + + if (count != NULL) { + *count = ret; + } + + return NT_STATUS_OK; +} + +NTSTATUS dbwrap_traverse_read(struct db_context *db, + int (*f)(struct db_record*, void*), + void *private_data, + int *count) +{ + int ret = db->traverse_read(db, f, private_data); + + if (ret < 0) { + return NT_STATUS_INTERNAL_DB_CORRUPTION; + } + + if (count != NULL) { + *count = ret; + } + + return NT_STATUS_OK; +} + +static void dbwrap_null_parser(TDB_DATA key, TDB_DATA val, void* data) +{ + return; +} + +NTSTATUS dbwrap_parse_record(struct db_context *db, TDB_DATA key, + void (*parser)(TDB_DATA key, TDB_DATA data, + void *private_data), + void *private_data) +{ + if (parser == NULL) { + parser = dbwrap_null_parser; + } + return db->parse_record(db, key, parser, private_data); +} + +struct dbwrap_parse_record_state { + struct db_context *db; + TDB_DATA key; + uint8_t _keybuf[64]; +}; + +static void dbwrap_parse_record_done(struct tevent_req *subreq); + +struct tevent_req *dbwrap_parse_record_send( + TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct db_context *db, + TDB_DATA key, + void (*parser)(TDB_DATA key, TDB_DATA data, void *private_data), + void *private_data, + enum dbwrap_req_state *req_state) +{ + struct tevent_req *req = NULL; + struct tevent_req *subreq = NULL; + struct dbwrap_parse_record_state *state = NULL; + NTSTATUS status; + + req = tevent_req_create(mem_ctx, &state, struct dbwrap_parse_record_state); + if (req == NULL) { + *req_state = DBWRAP_REQ_ERROR; + return NULL; + } + + *state = (struct dbwrap_parse_record_state) { + .db = db, + }; + + if (parser == NULL) { + parser = dbwrap_null_parser; + } + + *req_state = DBWRAP_REQ_INIT; + + if (db->parse_record_send == NULL) { + /* + * Backend doesn't implement async version, call sync one + */ + status = db->parse_record(db, key, parser, private_data); + if (tevent_req_nterror(req, status)) { + *req_state = DBWRAP_REQ_DONE; + return tevent_req_post(req, ev); + } + + *req_state = DBWRAP_REQ_DONE; + tevent_req_done(req); + return tevent_req_post(req, ev); + } + + /* + * Copy the key into our state ensuring the key data buffer is always + * available to all the dbwrap backends over the entire lifetime of the + * async request. Otherwise the caller might have free'd the key buffer. + */ + if (key.dsize > sizeof(state->_keybuf)) { + state->key.dptr = talloc_memdup(state, key.dptr, key.dsize); + if (tevent_req_nomem(state->key.dptr, req)) { + return tevent_req_post(req, ev); + } + } else { + memcpy(state->_keybuf, key.dptr, key.dsize); + state->key.dptr = state->_keybuf; + } + state->key.dsize = key.dsize; + + subreq = db->parse_record_send(state, + ev, + db, + state->key, + parser, + private_data, + req_state); + if (tevent_req_nomem(subreq, req)) { + *req_state = DBWRAP_REQ_ERROR; + return tevent_req_post(req, ev); + } + + tevent_req_set_callback(subreq, + dbwrap_parse_record_done, + req); + return req; +} + +static void dbwrap_parse_record_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct dbwrap_parse_record_state *state = tevent_req_data( + req, struct dbwrap_parse_record_state); + NTSTATUS status; + + status = state->db->parse_record_recv(subreq); + TALLOC_FREE(subreq); + if (!NT_STATUS_IS_OK(status)) { + tevent_req_nterror(req, status); + return; + } + + tevent_req_done(req); +} + +NTSTATUS dbwrap_parse_record_recv(struct tevent_req *req) +{ + return tevent_req_simple_recv_ntstatus(req); +} + +NTSTATUS dbwrap_do_locked(struct db_context *db, TDB_DATA key, + void (*fn)(struct db_record *rec, + TDB_DATA value, + void *private_data), + void *private_data) +{ + struct db_record *rec; + + if (db->do_locked != NULL) { + NTSTATUS status; + + if (db->lock_order != DBWRAP_LOCK_ORDER_NONE) { + dbwrap_lock_order_lock(db->name, db->lock_order); + } + + status = db->do_locked(db, key, fn, private_data); + + if (db->lock_order != DBWRAP_LOCK_ORDER_NONE) { + dbwrap_lock_order_unlock(db->name, db->lock_order); + } + + return status; + } + + rec = dbwrap_fetch_locked(db, db, key); + if (rec == NULL) { + return NT_STATUS_NO_MEMORY; + } + + /* + * Invalidate rec->value, nobody shall assume it's set from + * within dbwrap_do_locked(). + */ + rec->value_valid = false; + + fn(rec, rec->value, private_data); + + TALLOC_FREE(rec); + + return NT_STATUS_OK; +} + +int dbwrap_wipe(struct db_context *db) +{ + if (db->wipe == NULL) { + return dbwrap_fallback_wipe(db); + } + return db->wipe(db); +} + +int dbwrap_check(struct db_context *db) +{ + if (db->check == NULL) { + return dbwrap_fallback_check(db); + } + return db->check(db); +} + +int dbwrap_get_seqnum(struct db_context *db) +{ + return db->get_seqnum(db); +} + +int dbwrap_transaction_start(struct db_context *db) +{ + if (!db->persistent) { + /* + * dbwrap_ctdb has two different data models for persistent + * and non-persistent databases. Transactions are supported + * only for the persistent databases. This check is here to + * prevent breakages of the cluster case, autobuild at this + * point only tests non-clustered Samba. Before removing this + * check, please make sure that this facility has also been + * added to dbwrap_ctdb. + * + * Thanks, vl + */ + DEBUG(1, ("transactions not supported on non-persistent " + "database %s\n", db->name)); + return -1; + } + return db->transaction_start(db); +} + +NTSTATUS dbwrap_transaction_start_nonblock(struct db_context *db) +{ + if (db->transaction_start_nonblock) { + return db->transaction_start_nonblock(db); + } else { + return dbwrap_transaction_start(db) == 0 ? NT_STATUS_OK + : NT_STATUS_UNSUCCESSFUL; + } +} + +int dbwrap_transaction_commit(struct db_context *db) +{ + return db->transaction_commit(db); +} + +int dbwrap_transaction_cancel(struct db_context *db) +{ + return db->transaction_cancel(db); +} + +size_t dbwrap_db_id(struct db_context *db, uint8_t *id, size_t idlen) +{ + return db->id(db, id, idlen); +} + +bool dbwrap_is_persistent(struct db_context *db) +{ + return db->persistent; +} + +const char *dbwrap_name(struct db_context *db) +{ + return db->name; +} + +static ssize_t tdb_data_buf(const TDB_DATA *dbufs, int num_dbufs, + uint8_t *buf, size_t buflen) +{ + size_t needed = 0; + uint8_t *p = buf; + int i; + + for (i=0; i<num_dbufs; i++) { + size_t thislen = dbufs[i].dsize; + + needed += thislen; + if (needed < thislen) { + /* wrap */ + return -1; + } + + if (p != NULL && (thislen != 0) && (needed <= buflen)) { + memcpy(p, dbufs[i].dptr, thislen); + p += thislen; + } + } + + return needed; +} + + +TDB_DATA dbwrap_merge_dbufs(TALLOC_CTX *mem_ctx, + const TDB_DATA *dbufs, int num_dbufs) +{ + ssize_t len = tdb_data_buf(dbufs, num_dbufs, NULL, 0); + uint8_t *buf; + + if (len == -1) { + return (TDB_DATA) {0}; + } + + buf = talloc_array(mem_ctx, uint8_t, len); + if (buf == NULL) { + return (TDB_DATA) {0}; + } + + tdb_data_buf(dbufs, num_dbufs, buf, len); + + return (TDB_DATA) { .dptr = buf, .dsize = len }; +} diff --git a/lib/dbwrap/dbwrap.h b/lib/dbwrap/dbwrap.h new file mode 100644 index 0000000..9b8bf81 --- /dev/null +++ b/lib/dbwrap/dbwrap.h @@ -0,0 +1,239 @@ +/* + Unix SMB/CIFS implementation. + Database interface wrapper around tdb + Copyright (C) Volker Lendecke 2005-2007 + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. +*/ + +#ifndef __DBWRAP_H__ +#define __DBWRAP_H__ + +#include "replace.h" +#include <talloc.h> +#include <tevent.h> +#include "libcli/util/ntstatus.h" +#include "tdb.h" + +struct db_record; +struct db_context; + +enum dbwrap_lock_order { + DBWRAP_LOCK_ORDER_NONE = 0, /* Don't check lock orders for this db. */ + DBWRAP_LOCK_ORDER_1 = 1, + DBWRAP_LOCK_ORDER_2 = 2, + DBWRAP_LOCK_ORDER_3 = 3, + DBWRAP_LOCK_ORDER_4 = 4 +}; + +#define DBWRAP_FLAG_NONE 0x0000000000000000ULL +#define DBWRAP_FLAG_OPTIMIZE_READONLY_ACCESS 0x0000000000000001ULL + +enum dbwrap_req_state { + /** + * We are creating the request + */ + DBWRAP_REQ_INIT, + /** + * The request is queued and waiting to be dispatched + */ + DBWRAP_REQ_QUEUED, + /** + * We are waiting to receive the reply + */ + DBWRAP_REQ_DISPATCHED, + /** + * The request is finished + */ + DBWRAP_REQ_DONE, + /** + * The request errored out + */ + DBWRAP_REQ_ERROR +}; + +/* The following definitions come from lib/dbwrap.c */ + +TDB_DATA dbwrap_record_get_key(const struct db_record *rec); +TDB_DATA dbwrap_record_get_value(const struct db_record *rec); +NTSTATUS dbwrap_record_store(struct db_record *rec, TDB_DATA data, int flags); +NTSTATUS dbwrap_record_storev(struct db_record *rec, + const TDB_DATA *dbufs, int num_dbufs, int flags); +NTSTATUS dbwrap_record_delete(struct db_record *rec); +struct db_record *dbwrap_fetch_locked(struct db_context *db, + TALLOC_CTX *mem_ctx, + TDB_DATA key); +struct db_context *dbwrap_record_get_db(struct db_record *rec); + +void dbwrap_lock_order_lock(const char *db_name, + enum dbwrap_lock_order lock_order); +void dbwrap_lock_order_unlock(const char *db_name, + enum dbwrap_lock_order lock_order); + +NTSTATUS dbwrap_do_locked(struct db_context *db, TDB_DATA key, + void (*fn)(struct db_record *rec, + TDB_DATA value, + void *private_data), + void *private_data); + +NTSTATUS dbwrap_delete(struct db_context *db, TDB_DATA key); +NTSTATUS dbwrap_store(struct db_context *db, TDB_DATA key, + TDB_DATA data, int flags); +NTSTATUS dbwrap_fetch(struct db_context *db, TALLOC_CTX *mem_ctx, + TDB_DATA key, TDB_DATA *value); +bool dbwrap_exists(struct db_context *db, TDB_DATA key); +NTSTATUS dbwrap_traverse(struct db_context *db, + int (*f)(struct db_record*, void*), + void *private_data, + int *count); +NTSTATUS dbwrap_traverse_read(struct db_context *db, + int (*f)(struct db_record*, void*), + void *private_data, + int *count); +NTSTATUS dbwrap_parse_record(struct db_context *db, TDB_DATA key, + void (*parser)(TDB_DATA key, TDB_DATA data, + void *private_data), + void *private_data); +/** + * Async implementation of dbwrap_parse_record + * + * @param[in] mem_ctx talloc memory context to use. + * + * @param[in] ev tevent context to use + * + * @param[in] db Database to query + * + * @param[in] key Record key, the function makes a copy of this + * + * @param[in] parser Parser callback function + * + * @param[in] private_data Private data for the callback function + * + * @param[out] req_state Pointer to a enum dbwrap_req_state variable + * + * @note req_state is updated in the send function. To determine the final + * result of the request the caller should therefor not rely on req_state. The + * primary use case is to give the caller an indication whether the request is + * already sent to ctdb (DBWRAP_REQ_DISPATCHED) or if it's still stuck in the + * sendqueue (DBWRAP_REQ_QUEUED). + **/ +struct tevent_req *dbwrap_parse_record_send( + TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct db_context *db, + TDB_DATA key, + void (*parser)(TDB_DATA key, TDB_DATA data, void *private_data), + void *private_data, + enum dbwrap_req_state *req_state); +NTSTATUS dbwrap_parse_record_recv(struct tevent_req *req); +int dbwrap_wipe(struct db_context *db); +int dbwrap_check(struct db_context *db); +int dbwrap_get_seqnum(struct db_context *db); +/* Returns 0 if unknown. */ +int dbwrap_transaction_start(struct db_context *db); +NTSTATUS dbwrap_transaction_start_nonblock(struct db_context *db); +int dbwrap_transaction_commit(struct db_context *db); +int dbwrap_transaction_cancel(struct db_context *db); +size_t dbwrap_db_id(struct db_context *db, uint8_t *id, size_t idlen); +bool dbwrap_is_persistent(struct db_context *db); +const char *dbwrap_name(struct db_context *db); + +/* The following definitions come from lib/dbwrap_util.c */ + +NTSTATUS dbwrap_purge(struct db_context *db, TDB_DATA key); +NTSTATUS dbwrap_purge_bystring(struct db_context *db, const char *key); +NTSTATUS dbwrap_delete_bystring(struct db_context *db, const char *key); +NTSTATUS dbwrap_store_bystring(struct db_context *db, const char *key, + TDB_DATA data, int flags); +NTSTATUS dbwrap_fetch_bystring(struct db_context *db, TALLOC_CTX *mem_ctx, + const char *key, TDB_DATA *value); + +NTSTATUS dbwrap_fetch_int32(struct db_context *db, TDB_DATA key, + int32_t *result); +NTSTATUS dbwrap_fetch_int32_bystring(struct db_context *db, const char *keystr, + int32_t *result); +NTSTATUS dbwrap_store_int32_bystring(struct db_context *db, const char *keystr, + int32_t v); +NTSTATUS dbwrap_fetch_uint32_bystring(struct db_context *db, + const char *keystr, uint32_t *val); +NTSTATUS dbwrap_store_uint32_bystring(struct db_context *db, + const char *keystr, uint32_t v); +NTSTATUS dbwrap_change_uint32_atomic_bystring(struct db_context *db, + const char *keystr, + uint32_t *oldval, + uint32_t change_val); +NTSTATUS dbwrap_trans_change_uint32_atomic_bystring(struct db_context *db, + const char *keystr, + uint32_t *oldval, + uint32_t change_val); +NTSTATUS dbwrap_change_int32_atomic(struct db_context *db, + TDB_DATA key, + int32_t *oldval, + int32_t change_val); +NTSTATUS dbwrap_change_int32_atomic_bystring(struct db_context *db, + const char *keystr, + int32_t *oldval, + int32_t change_val); +NTSTATUS dbwrap_trans_change_int32_atomic_bystring(struct db_context *db, + const char *keystr, + int32_t *oldval, + int32_t change_val); +NTSTATUS dbwrap_trans_store(struct db_context *db, TDB_DATA key, TDB_DATA dbuf, + int flag); +NTSTATUS dbwrap_trans_delete(struct db_context *db, TDB_DATA key); +NTSTATUS dbwrap_trans_store_int32_bystring(struct db_context *db, + const char *keystr, + int32_t v); +NTSTATUS dbwrap_trans_store_uint32_bystring(struct db_context *db, + const char *keystr, + uint32_t v); +NTSTATUS dbwrap_trans_store_bystring(struct db_context *db, const char *key, + TDB_DATA data, int flags); +NTSTATUS dbwrap_trans_delete_bystring(struct db_context *db, const char *key); +NTSTATUS dbwrap_trans_do(struct db_context *db, + NTSTATUS (*action)(struct db_context *, void *), + void *private_data); +NTSTATUS dbwrap_trans_traverse(struct db_context *db, + int (*f)(struct db_record*, void*), + void *private_data); + +NTSTATUS dbwrap_delete_bystring_upper(struct db_context *db, const char *key); +NTSTATUS dbwrap_store_bystring_upper(struct db_context *db, const char *key, + TDB_DATA data, int flags); +NTSTATUS dbwrap_fetch_bystring_upper(struct db_context *db, TALLOC_CTX *mem_ctx, + const char *key, TDB_DATA *value); + +size_t dbwrap_marshall(struct db_context *db, uint8_t *buf, size_t bufsize); +NTSTATUS dbwrap_parse_marshall_buf(const uint8_t *buf, size_t buflen, + bool (*fn)(TDB_DATA key, TDB_DATA value, + void *private_data), + void *private_data); +NTSTATUS dbwrap_unmarshall(struct db_context *db, const uint8_t *buf, + size_t buflen); + +TDB_DATA dbwrap_merge_dbufs(TALLOC_CTX *mem_ctx, + const TDB_DATA *dbufs, int num_dbufs); + + +/** + * This opens a tdb file + */ +struct db_context *dbwrap_local_open(TALLOC_CTX *mem_ctx, + const char *name, + int hash_size, int tdb_flags, + int open_flags, mode_t mode, + enum dbwrap_lock_order lock_order, + uint64_t dbwrap_flags); + +#endif /* __DBWRAP_H__ */ diff --git a/lib/dbwrap/dbwrap_local_open.c b/lib/dbwrap/dbwrap_local_open.c new file mode 100644 index 0000000..20c5fa0 --- /dev/null +++ b/lib/dbwrap/dbwrap_local_open.c @@ -0,0 +1,46 @@ +/* + Unix SMB/CIFS implementation. + Database interface wrapper: local open code. + + Copyright (C) Rusty Russell 2012 + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. +*/ + +#include "includes.h" +#include "dbwrap/dbwrap.h" +#include "dbwrap/dbwrap_tdb.h" +#include "tdb.h" + +struct db_context *dbwrap_local_open(TALLOC_CTX *mem_ctx, + const char *name, + int hash_size, int tdb_flags, + int open_flags, mode_t mode, + enum dbwrap_lock_order lock_order, + uint64_t dbwrap_flags) +{ + struct db_context *db = NULL; + + db = db_open_tdb( + mem_ctx, + name, + hash_size, + tdb_flags, + open_flags, + mode, + lock_order, + dbwrap_flags); + + return db; +} diff --git a/lib/dbwrap/dbwrap_private.h b/lib/dbwrap/dbwrap_private.h new file mode 100644 index 0000000..3ac5ebf --- /dev/null +++ b/lib/dbwrap/dbwrap_private.h @@ -0,0 +1,93 @@ +/* + Unix SMB/CIFS implementation. + Database interface wrapper around tdb - private header + + Copyright (C) Volker Lendecke 2005-2007 + Copyright (C) Gregor Beck 2011 + Copyright (C) Michael Adam 2011 + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. +*/ + +#ifndef __DBWRAP_PRIVATE_H__ +#define __DBWRAP_PRIVATE_H__ + +struct tevent_context; +struct tevent_req; + +struct db_record { + struct db_context *db; + TDB_DATA key, value; + bool value_valid; + NTSTATUS (*storev)(struct db_record *rec, const TDB_DATA *dbufs, + int num_dbufs, int flag); + NTSTATUS (*delete_rec)(struct db_record *rec); + void *private_data; +}; + +struct db_context { + struct db_record *(*fetch_locked)(struct db_context *db, + TALLOC_CTX *mem_ctx, + TDB_DATA key); + int (*traverse)(struct db_context *db, + int (*f)(struct db_record *rec, + void *private_data), + void *private_data); + int (*traverse_read)(struct db_context *db, + int (*f)(struct db_record *rec, + void *private_data), + void *private_data); + int (*get_seqnum)(struct db_context *db); + int (*transaction_start)(struct db_context *db); + NTSTATUS (*transaction_start_nonblock)(struct db_context *db); + int (*transaction_commit)(struct db_context *db); + int (*transaction_cancel)(struct db_context *db); + NTSTATUS (*parse_record)(struct db_context *db, TDB_DATA key, + void (*parser)(TDB_DATA key, TDB_DATA data, + void *private_data), + void *private_data); + struct tevent_req *(*parse_record_send)( + TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct db_context *db, + TDB_DATA key, + void (*parser)(TDB_DATA key, TDB_DATA data, void *private_data), + void *private_data, + enum dbwrap_req_state *req_state); + NTSTATUS (*parse_record_recv)(struct tevent_req *req); + NTSTATUS (*do_locked)(struct db_context *db, TDB_DATA key, + void (*fn)(struct db_record *rec, + TDB_DATA value, + void *private_data), + void *private_data); + int (*exists)(struct db_context *db,TDB_DATA key); + int (*wipe)(struct db_context *db); + int (*check)(struct db_context *db); + size_t (*id)(struct db_context *db, uint8_t *id, size_t idlen); + + const char *name; + void *private_data; + enum dbwrap_lock_order lock_order; + bool persistent; +}; + +#define DBWRAP_LOCK_ORDER_MIN DBWRAP_LOCK_ORDER_1 +#define DBWRAP_LOCK_ORDER_MAX DBWRAP_LOCK_ORDER_4 + +#define DBWRAP_LOCK_ORDER_VALID(order) \ + (((order) >= DBWRAP_LOCK_ORDER_MIN) && \ + ((order) <= DBWRAP_LOCK_ORDER_MAX)) + +#endif /* __DBWRAP_PRIVATE_H__ */ + diff --git a/lib/dbwrap/dbwrap_rbt.c b/lib/dbwrap/dbwrap_rbt.c new file mode 100644 index 0000000..db456df --- /dev/null +++ b/lib/dbwrap/dbwrap_rbt.c @@ -0,0 +1,586 @@ +/* + Unix SMB/CIFS implementation. + Database interface wrapper around red-black trees + Copyright (C) Volker Lendecke 2007, 2008 + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. +*/ + +#include "includes.h" +#include "dbwrap/dbwrap.h" +#include "dbwrap/dbwrap_private.h" +#include "dbwrap/dbwrap_rbt.h" +#include "../lib/util/rbtree.h" +#include "../lib/util/dlinklist.h" + +#define DBWRAP_RBT_ALIGN(_size_) (((_size_)+15)&~15) + +struct db_rbt_ctx { + struct rb_root tree; + struct db_rbt_node *nodes; + size_t traverse_read; + struct db_rbt_node **traverse_nextp; +}; + +struct db_rbt_rec { + struct db_rbt_node *node; +}; + +/* The structure that ends up in the tree */ + +struct db_rbt_node { + struct rb_node rb_node; + size_t keysize, valuesize; + struct db_rbt_node *prev, *next; +}; + +/* + * Hide the ugly pointer calculations in a function + */ + +static struct db_rbt_node *db_rbt2node(struct rb_node *node) +{ + return (struct db_rbt_node *) + ((char *)node - offsetof(struct db_rbt_node, rb_node)); +} + +/* + * Compare two keys + */ + +static int db_rbt_compare(TDB_DATA a, TDB_DATA b) +{ + int res; + + res = memcmp(a.dptr, b.dptr, MIN(a.dsize, b.dsize)); + + if ((res < 0) || ((res == 0) && (a.dsize < b.dsize))) { + return -1; + } + if ((res > 0) || ((res == 0) && (a.dsize > b.dsize))) { + return 1; + } + return 0; +} + +/* + * dissect a db_rbt_node into its implicit key and value parts + */ + +static void db_rbt_parse_node(struct db_rbt_node *node, + TDB_DATA *key, TDB_DATA *value) +{ + size_t key_offset, value_offset; + + key_offset = DBWRAP_RBT_ALIGN(sizeof(struct db_rbt_node)); + key->dptr = ((uint8_t *)node) + key_offset; + key->dsize = node->keysize; + + value_offset = DBWRAP_RBT_ALIGN(node->keysize); + value->dptr = key->dptr + value_offset; + value->dsize = node->valuesize; +} + +static ssize_t db_rbt_reclen(size_t keylen, size_t valuelen) +{ + size_t len, tmp; + + len = DBWRAP_RBT_ALIGN(sizeof(struct db_rbt_node)); + + tmp = DBWRAP_RBT_ALIGN(keylen); + if (tmp < keylen) { + goto overflow; + } + + len += tmp; + if (len < tmp) { + goto overflow; + } + + len += valuelen; + if (len < valuelen) { + goto overflow; + } + + return len; +overflow: + return -1; +} + +static NTSTATUS db_rbt_storev(struct db_record *rec, + const TDB_DATA *dbufs, int num_dbufs, int flag) +{ + struct db_rbt_ctx *db_ctx = talloc_get_type_abort( + rec->db->private_data, struct db_rbt_ctx); + struct db_rbt_rec *rec_priv = (struct db_rbt_rec *)rec->private_data; + struct db_rbt_node *node; + + struct rb_node ** p; + struct rb_node *parent = NULL; + struct db_rbt_node *parent_node = NULL; + + ssize_t reclen; + TDB_DATA data, this_key, this_val; + void *to_free = NULL; + + if (db_ctx->traverse_read > 0) { + return NT_STATUS_MEDIA_WRITE_PROTECTED; + } + + if ((flag == TDB_INSERT) && (rec_priv->node != NULL)) { + return NT_STATUS_OBJECT_NAME_COLLISION; + } + + if ((flag == TDB_MODIFY) && (rec_priv->node == NULL)) { + return NT_STATUS_OBJECT_NAME_NOT_FOUND; + } + + if (num_dbufs == 1) { + data = dbufs[0]; + } else { + data = dbwrap_merge_dbufs(rec, dbufs, num_dbufs); + if (data.dptr == NULL) { + return NT_STATUS_NO_MEMORY; + } + to_free = data.dptr; + } + + if (rec_priv->node != NULL) { + + /* + * The record was around previously + */ + + db_rbt_parse_node(rec_priv->node, &this_key, &this_val); + + SMB_ASSERT(this_key.dsize == rec->key.dsize); + SMB_ASSERT(memcmp(this_key.dptr, rec->key.dptr, + this_key.dsize) == 0); + + if (this_val.dsize >= data.dsize) { + /* + * The new value fits into the old space + */ + memcpy(this_val.dptr, data.dptr, data.dsize); + rec_priv->node->valuesize = data.dsize; + TALLOC_FREE(to_free); + return NT_STATUS_OK; + } + } + + reclen = db_rbt_reclen(rec->key.dsize, data.dsize); + if (reclen == -1) { + TALLOC_FREE(to_free); + return NT_STATUS_INSUFFICIENT_RESOURCES; + } + + node = talloc_zero_size(db_ctx, reclen); + if (node == NULL) { + TALLOC_FREE(to_free); + return NT_STATUS_NO_MEMORY; + } + + if (rec_priv->node != NULL) { + if (db_ctx->traverse_nextp != NULL) { + if (*db_ctx->traverse_nextp == rec_priv->node) { + *db_ctx->traverse_nextp = node; + } + } + + /* + * We need to delete the key from the tree and start fresh, + * there's not enough space in the existing record + */ + + rb_erase(&rec_priv->node->rb_node, &db_ctx->tree); + DLIST_REMOVE(db_ctx->nodes, rec_priv->node); + + /* + * Keep the existing node around for a while: If the record + * existed before, we reference the key data in there. + */ + } + + node->keysize = rec->key.dsize; + node->valuesize = data.dsize; + + db_rbt_parse_node(node, &this_key, &this_val); + + memcpy(this_key.dptr, rec->key.dptr, node->keysize); + TALLOC_FREE(rec_priv->node); + rec_priv->node = node; + + if (node->valuesize > 0) { + memcpy(this_val.dptr, data.dptr, node->valuesize); + } + + parent = NULL; + p = &db_ctx->tree.rb_node; + + while (*p) { + struct db_rbt_node *r; + TDB_DATA search_key, search_val; + int res; + + r = db_rbt2node(*p); + + parent = (*p); + parent_node = r; + + db_rbt_parse_node(r, &search_key, &search_val); + + res = db_rbt_compare(this_key, search_key); + + if (res == -1) { + p = &(*p)->rb_left; + } + else if (res == 1) { + p = &(*p)->rb_right; + } + else { + smb_panic("someone messed with the tree"); + } + } + + rb_link_node(&node->rb_node, parent, p); + DLIST_ADD_AFTER(db_ctx->nodes, node, parent_node); + rb_insert_color(&node->rb_node, &db_ctx->tree); + + TALLOC_FREE(to_free); + + return NT_STATUS_OK; +} + +static NTSTATUS db_rbt_delete(struct db_record *rec) +{ + struct db_rbt_ctx *db_ctx = talloc_get_type_abort( + rec->db->private_data, struct db_rbt_ctx); + struct db_rbt_rec *rec_priv = (struct db_rbt_rec *)rec->private_data; + + if (db_ctx->traverse_read > 0) { + return NT_STATUS_MEDIA_WRITE_PROTECTED; + } + + if (rec_priv->node == NULL) { + return NT_STATUS_OK; + } + + if (db_ctx->traverse_nextp != NULL) { + if (*db_ctx->traverse_nextp == rec_priv->node) { + *db_ctx->traverse_nextp = rec_priv->node->next; + } + } + + rb_erase(&rec_priv->node->rb_node, &db_ctx->tree); + DLIST_REMOVE(db_ctx->nodes, rec_priv->node); + TALLOC_FREE(rec_priv->node); + + return NT_STATUS_OK; +} + +struct db_rbt_search_result { + TDB_DATA key; + TDB_DATA val; + struct db_rbt_node* node; +}; + +static bool db_rbt_search_internal(struct db_context *db, TDB_DATA key, + struct db_rbt_search_result *result) +{ + struct db_rbt_ctx *ctx = talloc_get_type_abort( + db->private_data, struct db_rbt_ctx); + + struct rb_node *n; + bool found = false; + struct db_rbt_node *r = NULL; + TDB_DATA search_key = { 0 }; + TDB_DATA search_val = { 0 }; + + n = ctx->tree.rb_node; + + while (n != NULL) { + int res; + + r = db_rbt2node(n); + + db_rbt_parse_node(r, &search_key, &search_val); + + res = db_rbt_compare(key, search_key); + + if (res == -1) { + n = n->rb_left; + } + else if (res == 1) { + n = n->rb_right; + } + else { + found = true; + break; + } + } + if (result != NULL) { + if (found) { + result->key = search_key; + result->val = search_val; + result->node = r; + } else { + ZERO_STRUCT(*result); + } + } + return found; +} + +static struct db_record *db_rbt_fetch_locked(struct db_context *db_ctx, + TALLOC_CTX *mem_ctx, + TDB_DATA key) +{ + struct db_rbt_rec *rec_priv; + struct db_record *result; + size_t size; + bool found; + struct db_rbt_search_result res; + + found = db_rbt_search_internal(db_ctx, key, &res); + + /* + * In this low-level routine, play tricks to reduce the number of + * tallocs to one. Not recommened for general use, but here it pays + * off. + */ + + size = DBWRAP_RBT_ALIGN(sizeof(struct db_record)) + + sizeof(struct db_rbt_rec); + + if (!found) { + /* + * We need to keep the key around for later store + */ + size += key.dsize; + } + + result = (struct db_record *)talloc_size(mem_ctx, size); + if (result == NULL) { + return NULL; + } + + rec_priv = (struct db_rbt_rec *) + ((char *)result + DBWRAP_RBT_ALIGN(sizeof(struct db_record))); + + result->storev = db_rbt_storev; + result->delete_rec = db_rbt_delete; + result->private_data = rec_priv; + + rec_priv->node = res.node; + result->value = res.val; + result->value_valid = true; + + if (found) { + result->key = res.key; + } + else { + result->key.dptr = (uint8_t *) + ((char *)rec_priv + sizeof(*rec_priv)); + result->key.dsize = key.dsize; + memcpy(result->key.dptr, key.dptr, key.dsize); + } + + return result; +} + +static int db_rbt_exists(struct db_context *db, TDB_DATA key) +{ + return db_rbt_search_internal(db, key, NULL); +} + +static int db_rbt_wipe(struct db_context *db) +{ + struct db_rbt_ctx *old_ctx = talloc_get_type_abort( + db->private_data, struct db_rbt_ctx); + struct db_rbt_ctx *new_ctx = talloc_zero(db, struct db_rbt_ctx); + if (new_ctx == NULL) { + return -1; + } + db->private_data = new_ctx; + talloc_free(old_ctx); + return 0; +} + +static NTSTATUS db_rbt_parse_record(struct db_context *db, TDB_DATA key, + void (*parser)(TDB_DATA key, TDB_DATA data, + void *private_data), + void *private_data) +{ + struct db_rbt_search_result res; + bool found = db_rbt_search_internal(db, key, &res); + + if (!found) { + return NT_STATUS_NOT_FOUND; + } + parser(res.key, res.val, private_data); + return NT_STATUS_OK; +} + +static int db_rbt_traverse_internal(struct db_context *db, + int (*f)(struct db_record *db, + void *private_data), + void *private_data, uint32_t* count, + bool rw) +{ + struct db_rbt_ctx *ctx = talloc_get_type_abort( + db->private_data, struct db_rbt_ctx); + struct db_rbt_node *cur = NULL; + struct db_rbt_node *next = NULL; + int ret; + + for (cur = ctx->nodes; cur != NULL; cur = next) { + struct db_record rec; + struct db_rbt_rec rec_priv; + + rec_priv.node = cur; + next = rec_priv.node->next; + + ZERO_STRUCT(rec); + rec.db = db; + rec.private_data = &rec_priv; + rec.storev = db_rbt_storev; + rec.delete_rec = db_rbt_delete; + db_rbt_parse_node(rec_priv.node, &rec.key, &rec.value); + rec.value_valid = true; + + if (rw) { + ctx->traverse_nextp = &next; + } + ret = f(&rec, private_data); + (*count) ++; + if (rw) { + ctx->traverse_nextp = NULL; + } + if (ret != 0) { + return ret; + } + if (rec_priv.node != NULL) { + next = rec_priv.node->next; + } + } + + return 0; +} + +static int db_rbt_traverse_read(struct db_context *db, + int (*f)(struct db_record *db, + void *private_data), + void *private_data) +{ + struct db_rbt_ctx *ctx = talloc_get_type_abort( + db->private_data, struct db_rbt_ctx); + uint32_t count = 0; + int ret; + + ctx->traverse_read++; + ret = db_rbt_traverse_internal(db, + f, private_data, &count, + false /* rw */); + ctx->traverse_read--; + if (ret != 0) { + return -1; + } + if (count > INT_MAX) { + return -1; + } + return count; +} + +static int db_rbt_traverse(struct db_context *db, + int (*f)(struct db_record *db, + void *private_data), + void *private_data) +{ + struct db_rbt_ctx *ctx = talloc_get_type_abort( + db->private_data, struct db_rbt_ctx); + uint32_t count = 0; + int ret; + + if (ctx->traverse_nextp != NULL) { + return -1; + }; + + if (ctx->traverse_read > 0) { + return db_rbt_traverse_read(db, f, private_data); + } + + ret = db_rbt_traverse_internal(db, + f, private_data, &count, + true /* rw */); + if (ret != 0) { + return -1; + } + if (count > INT_MAX) { + return -1; + } + return count; +} + +static int db_rbt_get_seqnum(struct db_context *db) +{ + return 0; +} + +static int db_rbt_trans_dummy(struct db_context *db) +{ + /* + * Transactions are pretty pointless in-memory, just return success. + */ + return 0; +} + +static size_t db_rbt_id(struct db_context *db, uint8_t *id, size_t idlen) +{ + if (idlen >= sizeof(struct db_context *)) { + memcpy(id, &db, sizeof(struct db_context *)); + } + return sizeof(struct db_context *); +} + +struct db_context *db_open_rbt(TALLOC_CTX *mem_ctx) +{ + struct db_context *result; + + result = talloc_zero(mem_ctx, struct db_context); + + if (result == NULL) { + return NULL; + } + + result->private_data = talloc_zero(result, struct db_rbt_ctx); + + if (result->private_data == NULL) { + TALLOC_FREE(result); + return NULL; + } + + result->fetch_locked = db_rbt_fetch_locked; + result->traverse = db_rbt_traverse; + result->traverse_read = db_rbt_traverse_read; + result->get_seqnum = db_rbt_get_seqnum; + result->transaction_start = db_rbt_trans_dummy; + result->transaction_commit = db_rbt_trans_dummy; + result->transaction_cancel = db_rbt_trans_dummy; + result->exists = db_rbt_exists; + result->wipe = db_rbt_wipe; + result->parse_record = db_rbt_parse_record; + result->id = db_rbt_id; + result->name = "dbwrap rbt"; + + return result; +} diff --git a/lib/dbwrap/dbwrap_rbt.h b/lib/dbwrap/dbwrap_rbt.h new file mode 100644 index 0000000..1716879 --- /dev/null +++ b/lib/dbwrap/dbwrap_rbt.h @@ -0,0 +1,29 @@ +/* + Unix SMB/CIFS implementation. + Database interface wrapper around red-black trees + Copyright (C) Volker Lendecke 2007, 2008 + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. +*/ + +#ifndef __DBWRAP_RBT_H__ +#define __DBWRAP_RBT_H__ + +#include <talloc.h> + +struct db_context; + +struct db_context *db_open_rbt(TALLOC_CTX *mem_ctx); + +#endif /* __DBWRAP_RBT_H__ */ diff --git a/lib/dbwrap/dbwrap_tdb.c b/lib/dbwrap/dbwrap_tdb.c new file mode 100644 index 0000000..6cd95fa --- /dev/null +++ b/lib/dbwrap/dbwrap_tdb.c @@ -0,0 +1,518 @@ +/* + Unix SMB/CIFS implementation. + Database interface wrapper around tdb + Copyright (C) Volker Lendecke 2005-2007 + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. +*/ + +#include "replace.h" +#include "dbwrap/dbwrap.h" +#include "dbwrap/dbwrap_private.h" +#include "dbwrap/dbwrap_tdb.h" +#include "lib/tdb_wrap/tdb_wrap.h" +#include "lib/util/util_tdb.h" +#include "lib/util/debug.h" +#include "lib/util/samba_util.h" +#include "system/filesys.h" +#include "lib/param/param.h" +#include "libcli/util/error.h" + +struct db_tdb_ctx { + struct tdb_wrap *wtdb; + + struct { + dev_t dev; + ino_t ino; + } id; +}; + +static NTSTATUS db_tdb_storev(struct db_record *rec, + const TDB_DATA *dbufs, int num_dbufs, int flag); +static NTSTATUS db_tdb_delete(struct db_record *rec); + +static void db_tdb_log_key(const char *prefix, TDB_DATA key) +{ + if (DEBUGLEVEL < 10) { + return; + } + if (DEBUGLEVEL == 10) { + /* + * Only fully spam at debuglevel > 10 + */ + key.dsize = MIN(10, key.dsize); + } + + if (key.dsize < 1024) { + char keystr[key.dsize*2+1]; + hex_encode_buf(keystr, key.dptr, key.dsize); + DBG_DEBUG("%s key %s\n", prefix, keystr); + return; + } + + dump_data(DEBUGLEVEL, key.dptr, key.dsize); +} + +static int db_tdb_record_destr(struct db_record* data) +{ + struct db_tdb_ctx *ctx = + talloc_get_type_abort(data->private_data, struct db_tdb_ctx); + + db_tdb_log_key("Unlocking", data->key); + tdb_chainunlock(ctx->wtdb->tdb, data->key); + return 0; +} + +struct tdb_fetch_locked_state { + TALLOC_CTX *mem_ctx; + struct db_record *result; +}; + +static int db_tdb_fetchlock_parse(TDB_DATA key, TDB_DATA data, + void *private_data) +{ + struct tdb_fetch_locked_state *state = + (struct tdb_fetch_locked_state *)private_data; + struct db_record *result; + + result = (struct db_record *)talloc_size( + state->mem_ctx, + sizeof(struct db_record) + key.dsize + data.dsize); + + if (result == NULL) { + return 0; + } + state->result = result; + + result->key.dsize = key.dsize; + result->key.dptr = ((uint8_t *)result) + sizeof(struct db_record); + memcpy(result->key.dptr, key.dptr, key.dsize); + + result->value.dsize = data.dsize; + + if (data.dsize > 0) { + result->value.dptr = result->key.dptr+key.dsize; + memcpy(result->value.dptr, data.dptr, data.dsize); + } + else { + result->value.dptr = NULL; + } + result->value_valid = true; + + return 0; +} + +static struct db_record *db_tdb_fetch_locked_internal( + struct db_context *db, + struct db_tdb_ctx *ctx, + TALLOC_CTX *mem_ctx, + TDB_DATA key) +{ + struct tdb_fetch_locked_state state; + int ret; + + state = (struct tdb_fetch_locked_state) { + .mem_ctx = mem_ctx, + }; + + ret = tdb_parse_record(ctx->wtdb->tdb, + key, + db_tdb_fetchlock_parse, + &state); + if ((ret < 0) && (tdb_error(ctx->wtdb->tdb) != TDB_ERR_NOEXIST)) { + tdb_chainunlock(ctx->wtdb->tdb, key); + return NULL; + } + + if (state.result == NULL) { + db_tdb_fetchlock_parse(key, tdb_null, &state); + } + + if (state.result == NULL) { + tdb_chainunlock(ctx->wtdb->tdb, key); + return NULL; + } + + talloc_set_destructor(state.result, db_tdb_record_destr); + + state.result->private_data = ctx; + state.result->storev = db_tdb_storev; + state.result->delete_rec = db_tdb_delete; + + DBG_DEBUG("Allocated locked data %p\n", state.result); + + return state.result; +} + +static struct db_record *db_tdb_fetch_locked( + struct db_context *db, TALLOC_CTX *mem_ctx, TDB_DATA key) +{ + struct db_tdb_ctx *ctx = talloc_get_type_abort(db->private_data, + struct db_tdb_ctx); + + db_tdb_log_key("Locking", key); + if (tdb_chainlock(ctx->wtdb->tdb, key) != 0) { + DEBUG(3, ("tdb_chainlock failed\n")); + return NULL; + } + return db_tdb_fetch_locked_internal(db, ctx, mem_ctx, key); +} + +static NTSTATUS db_tdb_do_locked(struct db_context *db, TDB_DATA key, + void (*fn)(struct db_record *rec, + TDB_DATA value, + void *private_data), + void *private_data) +{ + struct db_tdb_ctx *ctx = talloc_get_type_abort( + db->private_data, struct db_tdb_ctx); + uint8_t *buf = NULL; + struct db_record rec; + int ret; + + ret = tdb_chainlock(ctx->wtdb->tdb, key); + if (ret == -1) { + enum TDB_ERROR err = tdb_error(ctx->wtdb->tdb); + DBG_DEBUG("tdb_chainlock failed: %s\n", + tdb_errorstr(ctx->wtdb->tdb)); + return map_nt_error_from_tdb(err); + } + + ret = tdb_fetch_talloc(ctx->wtdb->tdb, key, ctx, &buf); + + if ((ret != 0) && (ret != ENOENT)) { + DBG_DEBUG("tdb_fetch_talloc failed: %s\n", + strerror(errno)); + tdb_chainunlock(ctx->wtdb->tdb, key); + return map_nt_error_from_unix_common(ret); + } + + rec = (struct db_record) { + .db = db, .key = key, + .value_valid = false, + .storev = db_tdb_storev, .delete_rec = db_tdb_delete, + .private_data = ctx + }; + + fn(&rec, + (TDB_DATA) { .dptr = buf, .dsize = talloc_get_size(buf) }, + private_data); + + tdb_chainunlock(ctx->wtdb->tdb, key); + + talloc_free(buf); + + return NT_STATUS_OK; +} + +static int db_tdb_exists(struct db_context *db, TDB_DATA key) +{ + struct db_tdb_ctx *ctx = talloc_get_type_abort( + db->private_data, struct db_tdb_ctx); + return tdb_exists(ctx->wtdb->tdb, key); +} + +static int db_tdb_wipe(struct db_context *db) +{ + struct db_tdb_ctx *ctx = talloc_get_type_abort( + db->private_data, struct db_tdb_ctx); + return tdb_wipe_all(ctx->wtdb->tdb); +} + +static int db_tdb_check(struct db_context *db) +{ + struct db_tdb_ctx *ctx = talloc_get_type_abort( + db->private_data, struct db_tdb_ctx); + return tdb_check(ctx->wtdb->tdb, NULL, NULL); +} + +struct db_tdb_parse_state { + void (*parser)(TDB_DATA key, TDB_DATA data, + void *private_data); + void *private_data; +}; + +/* + * tdb_parse_record expects a parser returning int, mixing up tdb and + * parser errors. Wrap around that by always returning 0 and have + * dbwrap_parse_record expect a parser returning void. + */ + +static int db_tdb_parser(TDB_DATA key, TDB_DATA data, void *private_data) +{ + struct db_tdb_parse_state *state = + (struct db_tdb_parse_state *)private_data; + state->parser(key, data, state->private_data); + return 0; +} + +static NTSTATUS db_tdb_parse(struct db_context *db, TDB_DATA key, + void (*parser)(TDB_DATA key, TDB_DATA data, + void *private_data), + void *private_data) +{ + struct db_tdb_ctx *ctx = talloc_get_type_abort( + db->private_data, struct db_tdb_ctx); + struct db_tdb_parse_state state; + int ret; + + state.parser = parser; + state.private_data = private_data; + + ret = tdb_parse_record(ctx->wtdb->tdb, key, db_tdb_parser, &state); + + if (ret != 0) { + return map_nt_error_from_tdb(tdb_error(ctx->wtdb->tdb)); + } + return NT_STATUS_OK; +} + +static NTSTATUS db_tdb_storev(struct db_record *rec, + const TDB_DATA *dbufs, int num_dbufs, int flag) +{ + struct db_tdb_ctx *ctx = talloc_get_type_abort(rec->private_data, + struct db_tdb_ctx); + struct tdb_context *tdb = ctx->wtdb->tdb; + NTSTATUS status = NT_STATUS_OK; + int ret; + + /* + * This has a bug: We need to replace rec->value for correct + * operation, but right now brlock and locking don't use the value + * anymore after it was stored. + */ + + ret = tdb_storev(tdb, rec->key, dbufs, num_dbufs, flag); + if (ret == -1) { + enum TDB_ERROR err = tdb_error(tdb); + status = map_nt_error_from_tdb(err); + } + return status; +} + +static NTSTATUS db_tdb_delete(struct db_record *rec) +{ + struct db_tdb_ctx *ctx = talloc_get_type_abort(rec->private_data, + struct db_tdb_ctx); + + if (tdb_delete(ctx->wtdb->tdb, rec->key) == 0) { + return NT_STATUS_OK; + } + + if (tdb_error(ctx->wtdb->tdb) == TDB_ERR_NOEXIST) { + return NT_STATUS_NOT_FOUND; + } + + return NT_STATUS_UNSUCCESSFUL; +} + +struct db_tdb_traverse_ctx { + struct db_context *db; + int (*f)(struct db_record *rec, void *private_data); + void *private_data; +}; + +static int db_tdb_traverse_func(TDB_CONTEXT *tdb, TDB_DATA kbuf, TDB_DATA dbuf, + void *private_data) +{ + struct db_tdb_traverse_ctx *ctx = + (struct db_tdb_traverse_ctx *)private_data; + struct db_record rec; + + rec.key = kbuf; + rec.value = dbuf; + rec.value_valid = true; + rec.storev = db_tdb_storev; + rec.delete_rec = db_tdb_delete; + rec.private_data = ctx->db->private_data; + rec.db = ctx->db; + + return ctx->f(&rec, ctx->private_data); +} + +static int db_tdb_traverse(struct db_context *db, + int (*f)(struct db_record *rec, void *private_data), + void *private_data) +{ + struct db_tdb_ctx *db_ctx = + talloc_get_type_abort(db->private_data, struct db_tdb_ctx); + struct db_tdb_traverse_ctx ctx; + + ctx.db = db; + ctx.f = f; + ctx.private_data = private_data; + return tdb_traverse(db_ctx->wtdb->tdb, db_tdb_traverse_func, &ctx); +} + +static NTSTATUS db_tdb_storev_deny(struct db_record *rec, + const TDB_DATA *dbufs, int num_dbufs, + int flag) +{ + return NT_STATUS_MEDIA_WRITE_PROTECTED; +} + +static NTSTATUS db_tdb_delete_deny(struct db_record *rec) +{ + return NT_STATUS_MEDIA_WRITE_PROTECTED; +} + +static int db_tdb_traverse_read_func(TDB_CONTEXT *tdb, TDB_DATA kbuf, TDB_DATA dbuf, + void *private_data) +{ + struct db_tdb_traverse_ctx *ctx = + (struct db_tdb_traverse_ctx *)private_data; + struct db_record rec; + + rec.key = kbuf; + rec.value = dbuf; + rec.value_valid = true; + rec.storev = db_tdb_storev_deny; + rec.delete_rec = db_tdb_delete_deny; + rec.private_data = ctx->db->private_data; + rec.db = ctx->db; + + return ctx->f(&rec, ctx->private_data); +} + +static int db_tdb_traverse_read(struct db_context *db, + int (*f)(struct db_record *rec, void *private_data), + void *private_data) +{ + struct db_tdb_ctx *db_ctx = + talloc_get_type_abort(db->private_data, struct db_tdb_ctx); + struct db_tdb_traverse_ctx ctx; + + ctx.db = db; + ctx.f = f; + ctx.private_data = private_data; + return tdb_traverse_read(db_ctx->wtdb->tdb, db_tdb_traverse_read_func, &ctx); +} + +static int db_tdb_get_seqnum(struct db_context *db) + +{ + struct db_tdb_ctx *db_ctx = + talloc_get_type_abort(db->private_data, struct db_tdb_ctx); + return tdb_get_seqnum(db_ctx->wtdb->tdb); +} + +static int db_tdb_transaction_start(struct db_context *db) +{ + struct db_tdb_ctx *db_ctx = + talloc_get_type_abort(db->private_data, struct db_tdb_ctx); + return tdb_transaction_start(db_ctx->wtdb->tdb) ? -1 : 0; +} + +static NTSTATUS db_tdb_transaction_start_nonblock(struct db_context *db) +{ + struct db_tdb_ctx *db_ctx = + talloc_get_type_abort(db->private_data, struct db_tdb_ctx); + int ret; + + ret = tdb_transaction_start_nonblock(db_ctx->wtdb->tdb); + if (ret != 0) { + return map_nt_error_from_tdb(tdb_error(db_ctx->wtdb->tdb)); + } + return NT_STATUS_OK; +} + +static int db_tdb_transaction_commit(struct db_context *db) +{ + struct db_tdb_ctx *db_ctx = + talloc_get_type_abort(db->private_data, struct db_tdb_ctx); + return tdb_transaction_commit(db_ctx->wtdb->tdb) ? -1 : 0; +} + +static int db_tdb_transaction_cancel(struct db_context *db) +{ + struct db_tdb_ctx *db_ctx = + talloc_get_type_abort(db->private_data, struct db_tdb_ctx); + tdb_transaction_cancel(db_ctx->wtdb->tdb); + return 0; +} + +static size_t db_tdb_id(struct db_context *db, uint8_t *id, size_t idlen) +{ + struct db_tdb_ctx *db_ctx = + talloc_get_type_abort(db->private_data, struct db_tdb_ctx); + + if (idlen >= sizeof(db_ctx->id)) { + memcpy(id, &db_ctx->id, sizeof(db_ctx->id)); + } + + return sizeof(db_ctx->id); +} + +struct db_context *db_open_tdb(TALLOC_CTX *mem_ctx, + const char *name, + int hash_size, int tdb_flags, + int open_flags, mode_t mode, + enum dbwrap_lock_order lock_order, + uint64_t dbwrap_flags) +{ + struct db_context *result = NULL; + struct db_tdb_ctx *db_tdb; + struct stat st; + + result = talloc_zero(mem_ctx, struct db_context); + if (result == NULL) { + DEBUG(0, ("talloc failed\n")); + goto fail; + } + + result->private_data = db_tdb = talloc(result, struct db_tdb_ctx); + if (db_tdb == NULL) { + DEBUG(0, ("talloc failed\n")); + goto fail; + } + result->lock_order = lock_order; + + db_tdb->wtdb = tdb_wrap_open(db_tdb, name, hash_size, tdb_flags, + open_flags, mode); + if (db_tdb->wtdb == NULL) { + DEBUG(3, ("Could not open tdb: %s\n", strerror(errno))); + goto fail; + } + + ZERO_STRUCT(db_tdb->id); + + if (fstat(tdb_fd(db_tdb->wtdb->tdb), &st) == -1) { + DEBUG(3, ("fstat failed: %s\n", strerror(errno))); + goto fail; + } + db_tdb->id.dev = st.st_dev; + db_tdb->id.ino = st.st_ino; + + result->fetch_locked = db_tdb_fetch_locked; + result->do_locked = db_tdb_do_locked; + result->traverse = db_tdb_traverse; + result->traverse_read = db_tdb_traverse_read; + result->parse_record = db_tdb_parse; + result->get_seqnum = db_tdb_get_seqnum; + result->persistent = ((tdb_flags & TDB_CLEAR_IF_FIRST) == 0); + result->transaction_start = db_tdb_transaction_start; + result->transaction_start_nonblock = db_tdb_transaction_start_nonblock; + result->transaction_commit = db_tdb_transaction_commit; + result->transaction_cancel = db_tdb_transaction_cancel; + result->exists = db_tdb_exists; + result->wipe = db_tdb_wipe; + result->id = db_tdb_id; + result->check = db_tdb_check; + result->name = tdb_name(db_tdb->wtdb->tdb); + return result; + + fail: + TALLOC_FREE(result); + return NULL; +} diff --git a/lib/dbwrap/dbwrap_tdb.h b/lib/dbwrap/dbwrap_tdb.h new file mode 100644 index 0000000..d5f49c7 --- /dev/null +++ b/lib/dbwrap/dbwrap_tdb.h @@ -0,0 +1,35 @@ +/* + Unix SMB/CIFS implementation. + Database interface wrapper around tdb + Copyright (C) Volker Lendecke 2005-2007 + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. +*/ + +#ifndef __DBWRAP_TDB_H__ +#define __DBWRAP_TDB_H__ + +#include <talloc.h> + +struct db_context; + +struct db_context *db_open_tdb(TALLOC_CTX *mem_ctx, + const char *name, + int hash_size, int tdb_flags, + int open_flags, mode_t mode, + enum dbwrap_lock_order lock_order, + uint64_t dbwrap_flags); + + +#endif /* __DBWRAP_TDB_H__ */ diff --git a/lib/dbwrap/dbwrap_util.c b/lib/dbwrap/dbwrap_util.c new file mode 100644 index 0000000..df6dea4 --- /dev/null +++ b/lib/dbwrap/dbwrap_util.c @@ -0,0 +1,737 @@ +/* + Unix SMB/CIFS implementation. + Utility functions for the dbwrap API + Copyright (C) Volker Lendecke 2007 + Copyright (C) Michael Adam 2009 + Copyright (C) Jim McDonough <jmcd@us.ibm.com> 2006 + + Major code contributions from Aleksey Fedoseev (fedoseev@ru.ibm.com) + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. +*/ + +#include "includes.h" +#include "dbwrap.h" +#include "lib/util/util_tdb.h" + +struct dbwrap_fetch_int32_state { + NTSTATUS status; + int32_t result; +}; + +static void dbwrap_fetch_int32_parser(TDB_DATA key, TDB_DATA data, + void *private_data) +{ + struct dbwrap_fetch_int32_state *state = + (struct dbwrap_fetch_int32_state *)private_data; + + if (data.dsize != sizeof(state->result)) { + state->status = NT_STATUS_INTERNAL_DB_CORRUPTION; + return; + } + state->result = IVAL(data.dptr, 0); + state->status = NT_STATUS_OK; +} + +NTSTATUS dbwrap_fetch_int32(struct db_context *db, TDB_DATA key, + int32_t *result) +{ + struct dbwrap_fetch_int32_state state; + NTSTATUS status; + + if (result == NULL) { + return NT_STATUS_INVALID_PARAMETER; + } + + state.status = NT_STATUS_INTERNAL_ERROR; + + status = dbwrap_parse_record(db, key, dbwrap_fetch_int32_parser, &state); + if (!NT_STATUS_IS_OK(status)) { + return status; + } + + if (NT_STATUS_IS_OK(state.status)) { + *result = state.result; + } + return state.status; +} + +NTSTATUS dbwrap_fetch_int32_bystring(struct db_context *db, const char *keystr, + int32_t *result) +{ + return dbwrap_fetch_int32(db, string_term_tdb_data(keystr), result); +} + +NTSTATUS dbwrap_store_int32_bystring(struct db_context *db, const char *keystr, + int32_t v) +{ + uint8_t v_store[sizeof(int32_t)]; + TDB_DATA data = { .dptr = v_store, .dsize = sizeof(v_store) }; + NTSTATUS status; + + SIVAL(v_store, 0, v); + + status = dbwrap_store(db, string_term_tdb_data(keystr), data, + TDB_REPLACE); + return status; +} + +struct dbwrap_fetch_uint32_state { + NTSTATUS status; + uint32_t result; +}; + +static void dbwrap_fetch_uint32_parser(TDB_DATA key, TDB_DATA data, + void *private_data) +{ + struct dbwrap_fetch_uint32_state *state = + (struct dbwrap_fetch_uint32_state *)private_data; + + if (data.dsize != sizeof(state->result)) { + state->status = NT_STATUS_INTERNAL_DB_CORRUPTION; + return; + } + state->result = IVAL(data.dptr, 0); + state->status = NT_STATUS_OK; +} + +NTSTATUS dbwrap_fetch_uint32_bystring(struct db_context *db, + const char *keystr, uint32_t *val) +{ + struct dbwrap_fetch_uint32_state state; + NTSTATUS status; + + if (val == NULL) { + return NT_STATUS_INVALID_PARAMETER; + } + + state.status = NT_STATUS_INTERNAL_ERROR; + + status = dbwrap_parse_record(db, string_term_tdb_data(keystr), + dbwrap_fetch_uint32_parser, &state); + if (!NT_STATUS_IS_OK(status)) { + return status; + } + if (NT_STATUS_IS_OK(state.status)) { + *val = state.result; + } + return state.status; +} + +NTSTATUS dbwrap_store_uint32_bystring(struct db_context *db, + const char *keystr, uint32_t v) +{ + uint8_t v_store[sizeof(uint32_t)]; + TDB_DATA data = { .dptr = v_store, .dsize = sizeof(v_store) }; + NTSTATUS status; + + SIVAL(v_store, 0, v); + + status = dbwrap_store(db, string_term_tdb_data(keystr), data, + TDB_REPLACE); + return status; +} + +/** + * Atomic unsigned integer change (addition): + * + * if value does not exist yet in the db, use *oldval as initial old value. + * return old value in *oldval. + * store *oldval + change_val to db. + */ + +struct dbwrap_change_uint32_atomic_context { + const char *keystr; + uint32_t *oldval; + uint32_t change_val; +}; + +static NTSTATUS dbwrap_change_uint32_atomic_action(struct db_context *db, + void *private_data) +{ + struct db_record *rec; + uint32_t val = (uint32_t)-1; + uint32_t v_store; + NTSTATUS ret; + struct dbwrap_change_uint32_atomic_context *state; + TDB_DATA value; + + state = (struct dbwrap_change_uint32_atomic_context *)private_data; + + rec = dbwrap_fetch_locked(db, talloc_tos(), + string_term_tdb_data(state->keystr)); + if (!rec) { + return NT_STATUS_UNSUCCESSFUL; + } + + value = dbwrap_record_get_value(rec); + + if (value.dptr == NULL) { + val = *(state->oldval); + } else if (value.dsize == sizeof(val)) { + val = IVAL(value.dptr, 0); + *(state->oldval) = val; + } else { + ret = NT_STATUS_UNSUCCESSFUL; + goto done; + } + + val += state->change_val; + + SIVAL(&v_store, 0, val); + + ret = dbwrap_record_store(rec, + make_tdb_data((const uint8_t *)&v_store, + sizeof(v_store)), + TDB_REPLACE); + +done: + TALLOC_FREE(rec); + return ret; +} + +NTSTATUS dbwrap_change_uint32_atomic_bystring(struct db_context *db, + const char *keystr, + uint32_t *oldval, + uint32_t change_val) +{ + NTSTATUS ret; + struct dbwrap_change_uint32_atomic_context state; + + state.keystr = keystr; + state.oldval = oldval; + state.change_val = change_val; + + ret = dbwrap_change_uint32_atomic_action(db, &state); + + return ret; +} + +NTSTATUS dbwrap_trans_change_uint32_atomic_bystring(struct db_context *db, + const char *keystr, + uint32_t *oldval, + uint32_t change_val) +{ + NTSTATUS ret; + struct dbwrap_change_uint32_atomic_context state; + + state.keystr = keystr; + state.oldval = oldval; + state.change_val = change_val; + + ret = dbwrap_trans_do(db, dbwrap_change_uint32_atomic_action, &state); + + return ret; +} + +/** + * Atomic integer change (addition): + * + * if value does not exist yet in the db, use *oldval as initial old value. + * return old value in *oldval. + * store *oldval + change_val to db. + */ + +struct dbwrap_change_int32_atomic_context { + TDB_DATA key; + int32_t *oldval; + int32_t change_val; +}; + +static NTSTATUS dbwrap_change_int32_atomic_action(struct db_context *db, + void *private_data) +{ + struct db_record *rec; + int32_t val = -1; + int32_t v_store; + NTSTATUS ret; + struct dbwrap_change_int32_atomic_context *state; + TDB_DATA value; + + state = (struct dbwrap_change_int32_atomic_context *)private_data; + + rec = dbwrap_fetch_locked(db, talloc_tos(), state->key); + if (!rec) { + return NT_STATUS_UNSUCCESSFUL; + } + + value = dbwrap_record_get_value(rec); + + if (value.dptr == NULL) { + val = *(state->oldval); + } else if (value.dsize == sizeof(val)) { + val = IVAL(value.dptr, 0); + *(state->oldval) = val; + } else { + ret = NT_STATUS_UNSUCCESSFUL; + goto done; + } + + val += state->change_val; + + SIVAL(&v_store, 0, val); + + ret = dbwrap_record_store(rec, + make_tdb_data((const uint8_t *)&v_store, + sizeof(v_store)), + TDB_REPLACE); + +done: + TALLOC_FREE(rec); + return ret; +} + +NTSTATUS dbwrap_change_int32_atomic(struct db_context *db, + TDB_DATA key, + int32_t *oldval, + int32_t change_val) +{ + NTSTATUS ret; + struct dbwrap_change_int32_atomic_context state; + + state.key = key; + state.oldval = oldval; + state.change_val = change_val; + + ret = dbwrap_change_int32_atomic_action(db, &state); + + return ret; +} + +NTSTATUS dbwrap_change_int32_atomic_bystring(struct db_context *db, + const char *keystr, + int32_t *oldval, + int32_t change_val) +{ + return dbwrap_change_int32_atomic(db, string_term_tdb_data(keystr), + oldval, change_val); +} + +NTSTATUS dbwrap_trans_change_int32_atomic_bystring(struct db_context *db, + const char *keystr, + int32_t *oldval, + int32_t change_val) +{ + NTSTATUS ret; + struct dbwrap_change_int32_atomic_context state; + + state.key = string_term_tdb_data(keystr); + state.oldval = oldval; + state.change_val = change_val; + + ret = dbwrap_trans_do(db, dbwrap_change_int32_atomic_action, &state); + + return ret; +} + +struct dbwrap_store_context { + TDB_DATA *key; + TDB_DATA *dbuf; + int flag; +}; + +static NTSTATUS dbwrap_store_action(struct db_context *db, void *private_data) +{ + NTSTATUS status; + struct dbwrap_store_context *store_ctx; + + store_ctx = (struct dbwrap_store_context *)private_data; + + status = dbwrap_store(db, *(store_ctx->key), *(store_ctx->dbuf), + store_ctx->flag); + if (!NT_STATUS_IS_OK(status)) { + DEBUG(5, ("store returned %s\n", nt_errstr(status))); + } + + return status; +} + +NTSTATUS dbwrap_trans_store(struct db_context *db, TDB_DATA key, TDB_DATA dbuf, + int flag) +{ + NTSTATUS status; + struct dbwrap_store_context store_ctx; + + store_ctx.key = &key; + store_ctx.dbuf = &dbuf; + store_ctx.flag = flag; + + status = dbwrap_trans_do(db, dbwrap_store_action, &store_ctx); + + return status; +} + +static NTSTATUS dbwrap_delete_action(struct db_context * db, void *private_data) +{ + NTSTATUS status; + TDB_DATA *key = (TDB_DATA *)private_data; + + status = dbwrap_delete(db, *key); + if (!NT_STATUS_IS_OK(status)) { + DBG_INFO("dbwrap_record_delete returned %s\n", + nt_errstr(status)); + } + return status; +} + +NTSTATUS dbwrap_trans_delete(struct db_context *db, TDB_DATA key) +{ + NTSTATUS status; + + status = dbwrap_trans_do(db, dbwrap_delete_action, &key); + + return status; +} + +NTSTATUS dbwrap_trans_store_int32_bystring(struct db_context *db, + const char *keystr, + int32_t v) +{ + int32_t v_store; + + SIVAL(&v_store, 0, v); + + return dbwrap_trans_store(db, string_term_tdb_data(keystr), + make_tdb_data((const uint8_t *)&v_store, + sizeof(v_store)), + TDB_REPLACE); +} + +NTSTATUS dbwrap_trans_store_uint32_bystring(struct db_context *db, + const char *keystr, + uint32_t v) +{ + uint32_t v_store; + + SIVAL(&v_store, 0, v); + + return dbwrap_trans_store(db, string_term_tdb_data(keystr), + make_tdb_data((const uint8_t *)&v_store, + sizeof(v_store)), + TDB_REPLACE); +} + +NTSTATUS dbwrap_trans_store_bystring(struct db_context *db, const char *key, + TDB_DATA data, int flags) +{ + return dbwrap_trans_store(db, string_term_tdb_data(key), data, flags); +} + +NTSTATUS dbwrap_trans_delete_bystring(struct db_context *db, const char *key) +{ + return dbwrap_trans_delete(db, string_term_tdb_data(key)); +} + +/** + * Wrap db action(s) into a transaction. + */ +NTSTATUS dbwrap_trans_do(struct db_context *db, + NTSTATUS (*action)(struct db_context *, void *), + void *private_data) +{ + int res; + NTSTATUS status; + + res = dbwrap_transaction_start(db); + if (res != 0) { + DEBUG(5, ("transaction_start failed\n")); + return NT_STATUS_INTERNAL_DB_CORRUPTION; + } + + status = action(db, private_data); + if (!NT_STATUS_IS_OK(status)) { + if (dbwrap_transaction_cancel(db) != 0) { + smb_panic("Cancelling transaction failed"); + } + return status; + } + + res = dbwrap_transaction_commit(db); + if (res == 0) { + return NT_STATUS_OK; + } + + DEBUG(2, ("transaction_commit failed\n")); + return NT_STATUS_INTERNAL_DB_CORRUPTION; +} + +struct dbwrap_trans_traverse_action_ctx { + int (*f)(struct db_record* rec, void* private_data); + void* private_data; +}; + + +static NTSTATUS dbwrap_trans_traverse_action(struct db_context* db, void* private_data) +{ + struct dbwrap_trans_traverse_action_ctx* ctx = + (struct dbwrap_trans_traverse_action_ctx*)private_data; + + NTSTATUS status = dbwrap_traverse(db, ctx->f, ctx->private_data, NULL); + + return status; +} + +NTSTATUS dbwrap_trans_traverse(struct db_context *db, + int (*f)(struct db_record*, void*), + void *private_data) +{ + struct dbwrap_trans_traverse_action_ctx ctx = { + .f = f, + .private_data = private_data, + }; + return dbwrap_trans_do(db, dbwrap_trans_traverse_action, &ctx); +} + +NTSTATUS dbwrap_purge(struct db_context *db, TDB_DATA key) +{ + NTSTATUS status; + + status = dbwrap_delete(db, key); + if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_FOUND)) { + status = NT_STATUS_OK; + } + + return status; +} + +NTSTATUS dbwrap_purge_bystring(struct db_context *db, const char *key) +{ + return dbwrap_purge(db, string_term_tdb_data(key)); +} + +NTSTATUS dbwrap_delete_bystring(struct db_context *db, const char *key) +{ + return dbwrap_delete(db, string_term_tdb_data(key)); +} + +NTSTATUS dbwrap_store_bystring(struct db_context *db, const char *key, + TDB_DATA data, int flags) +{ + return dbwrap_store(db, string_term_tdb_data(key), data, flags); +} + +NTSTATUS dbwrap_fetch_bystring(struct db_context *db, TALLOC_CTX *mem_ctx, + const char *key, TDB_DATA *value) +{ + return dbwrap_fetch(db, mem_ctx, string_term_tdb_data(key), value); +} + + + +NTSTATUS dbwrap_delete_bystring_upper(struct db_context *db, const char *key) +{ + char *key_upper; + NTSTATUS status; + + key_upper = talloc_strdup_upper(talloc_tos(), key); + if (key_upper == NULL) { + return NT_STATUS_NO_MEMORY; + } + + status = dbwrap_delete_bystring(db, key_upper); + + talloc_free(key_upper); + return status; +} + +NTSTATUS dbwrap_store_bystring_upper(struct db_context *db, const char *key, + TDB_DATA data, int flags) +{ + char *key_upper; + NTSTATUS status; + + key_upper = talloc_strdup_upper(talloc_tos(), key); + if (key_upper == NULL) { + return NT_STATUS_NO_MEMORY; + } + + status = dbwrap_store_bystring(db, key_upper, data, flags); + + talloc_free(key_upper); + return status; +} + +NTSTATUS dbwrap_fetch_bystring_upper(struct db_context *db, TALLOC_CTX *mem_ctx, + const char *key, TDB_DATA *value) +{ + char *key_upper; + NTSTATUS status; + + key_upper = talloc_strdup_upper(talloc_tos(), key); + if (key_upper == NULL) { + return NT_STATUS_NO_MEMORY; + } + + status = dbwrap_fetch_bystring(db, mem_ctx, key_upper, value); + + talloc_free(key_upper); + return status; +} + +struct dbwrap_marshall_state { + uint8_t *buf; + size_t bufsize; + size_t dbsize; +}; + +static int dbwrap_marshall_fn(struct db_record *rec, void *private_data) +{ + struct dbwrap_marshall_state *state = private_data; + TDB_DATA key, value; + size_t new_dbsize; + + key = dbwrap_record_get_key(rec); + value = dbwrap_record_get_value(rec); + + new_dbsize = state->dbsize; + new_dbsize += 8 + key.dsize; + new_dbsize += 8 + value.dsize; + + if (new_dbsize <= state->bufsize) { + uint8_t *p = state->buf + state->dbsize; + + SBVAL(p, 0, key.dsize); + p += 8; + memcpy(p, key.dptr, key.dsize); + p += key.dsize; + + SBVAL(p, 0, value.dsize); + p += 8; + memcpy(p, value.dptr, value.dsize); + } + state->dbsize = new_dbsize; + return 0; +} + +size_t dbwrap_marshall(struct db_context *db, uint8_t *buf, size_t bufsize) +{ + struct dbwrap_marshall_state state; + + state.bufsize = bufsize; + state.buf = buf; + state.dbsize = 0; + + dbwrap_traverse_read(db, dbwrap_marshall_fn, &state, NULL); + + return state.dbsize; +} + +static ssize_t dbwrap_unmarshall_get_data(const uint8_t *buf, size_t buflen, + size_t ofs, TDB_DATA *pdata) +{ + uint64_t space, len; + const uint8_t *p; + + if (ofs == buflen) { + return 0; + } + if (ofs > buflen) { + return -1; + } + + space = buflen - ofs; + if (space < 8) { + return -1; + } + + p = buf + ofs; + len = BVAL(p, 0); + + p += 8; + space -= 8; + + if (len > space) { + return -1; + } + + *pdata = (TDB_DATA) { .dptr = discard_const_p(uint8_t, p), + .dsize = len }; + return len + 8; +} + +NTSTATUS dbwrap_parse_marshall_buf(const uint8_t *buf, size_t buflen, + bool (*fn)(TDB_DATA key, TDB_DATA value, + void *private_data), + void *private_data) +{ + size_t ofs = 0; + + while (true) { + ssize_t len; + TDB_DATA key, value; + bool ok; + + len = dbwrap_unmarshall_get_data(buf, buflen, ofs, &key); + if (len == 0) { + break; + } + if (len == -1) { + return NT_STATUS_INVALID_PARAMETER; + } + ofs += len; + + len = dbwrap_unmarshall_get_data(buf, buflen, ofs, &value); + if (len == 0) { + break; + } + if (len == -1) { + return NT_STATUS_INVALID_PARAMETER; + } + ofs += len; + + ok = fn(key, value, private_data); + if (!ok) { + break; + } + } + + return NT_STATUS_OK; +} + +struct dbwrap_unmarshall_state { + struct db_context *db; + NTSTATUS ret; +}; + +static bool dbwrap_unmarshall_fn(TDB_DATA key, TDB_DATA value, + void *private_data) +{ + struct dbwrap_unmarshall_state *state = private_data; + NTSTATUS status; + + status = dbwrap_store(state->db, key, value, 0); + if (!NT_STATUS_IS_OK(status)) { + DBG_DEBUG("dbwrap_record_store failed: %s\n", + nt_errstr(status)); + state->ret = status; + return false; + } + + return true; +} + +NTSTATUS dbwrap_unmarshall(struct db_context *db, const uint8_t *buf, + size_t buflen) +{ + struct dbwrap_unmarshall_state state = { .db = db }; + NTSTATUS status; + + status = dbwrap_parse_marshall_buf(buf, buflen, + dbwrap_unmarshall_fn, &state); + if (!NT_STATUS_IS_OK(status)) { + return status; + } + return state.ret; +} diff --git a/lib/dbwrap/wscript_build b/lib/dbwrap/wscript_build new file mode 100644 index 0000000..0e5f961 --- /dev/null +++ b/lib/dbwrap/wscript_build @@ -0,0 +1,8 @@ +SRC = '''dbwrap.c dbwrap_util.c dbwrap_rbt.c dbwrap_tdb.c + dbwrap_local_open.c''' +DEPS= '''samba-util util_tdb samba-errors tdb tdb-wrap tevent tevent-util''' + +bld.SAMBA_LIBRARY('dbwrap', + source=SRC, + deps=DEPS, + private_library=True) |