From e945511aae52c0bc50007ffc703241c7da1db372 Mon Sep 17 00:00:00 2001 From: Michael Adam Date: Fri, 11 May 2012 22:11:42 +0200 Subject: move the dbwrap library to the top level Autobuild-User: Michael Adam Autobuild-Date: Mon May 14 04:04:55 CEST 2012 on sn-devel-104 --- lib/dbwrap/dbwrap.c | 398 +++++++++++++++++++++++ lib/dbwrap/dbwrap.h | 131 ++++++++ lib/dbwrap/dbwrap_cache.c | 225 +++++++++++++ lib/dbwrap/dbwrap_cache.h | 32 ++ lib/dbwrap/dbwrap_file.c | 418 ++++++++++++++++++++++++ lib/dbwrap/dbwrap_file.h | 36 +++ lib/dbwrap/dbwrap_private.h | 70 ++++ lib/dbwrap/dbwrap_rbt.c | 450 ++++++++++++++++++++++++++ lib/dbwrap/dbwrap_rbt.h | 29 ++ lib/dbwrap/dbwrap_tdb.c | 447 +++++++++++++++++++++++++ lib/dbwrap/dbwrap_tdb.h | 35 ++ lib/dbwrap/dbwrap_util.c | 539 +++++++++++++++++++++++++++++++ lib/dbwrap/wscript_build | 11 + source3/Makefile.in | 10 +- source3/lib/dbwrap/dbwrap.c | 398 ----------------------- source3/lib/dbwrap/dbwrap.h | 131 -------- source3/lib/dbwrap/dbwrap_cache.c | 225 ------------- source3/lib/dbwrap/dbwrap_cache.h | 32 -- source3/lib/dbwrap/dbwrap_file.c | 418 ------------------------ source3/lib/dbwrap/dbwrap_file.h | 36 --- source3/lib/dbwrap/dbwrap_private.h | 70 ---- source3/lib/dbwrap/dbwrap_rbt.c | 450 -------------------------- source3/lib/dbwrap/dbwrap_rbt.h | 29 -- source3/lib/dbwrap/dbwrap_tdb.c | 447 ------------------------- source3/lib/dbwrap/dbwrap_tdb.h | 35 -- source3/lib/dbwrap/dbwrap_util.c | 539 ------------------------------- source3/lib/dbwrap/dbwrap_watch.c | 2 +- source3/lib/dbwrap/dbwrap_watch.h | 2 +- source3/wscript_build | 5 - source4/ntvfs/posix/python/pyxattr_tdb.c | 6 +- wscript_build | 1 + 31 files changed, 2832 insertions(+), 2825 deletions(-) create mode 100644 lib/dbwrap/dbwrap.c create mode 100644 lib/dbwrap/dbwrap.h create mode 100644 lib/dbwrap/dbwrap_cache.c create mode 100644 lib/dbwrap/dbwrap_cache.h create mode 100644 lib/dbwrap/dbwrap_file.c create mode 100644 lib/dbwrap/dbwrap_file.h create mode 100644 lib/dbwrap/dbwrap_private.h create mode 100644 lib/dbwrap/dbwrap_rbt.c create mode 100644 lib/dbwrap/dbwrap_rbt.h create mode 100644 lib/dbwrap/dbwrap_tdb.c create mode 100644 lib/dbwrap/dbwrap_tdb.h create mode 100644 lib/dbwrap/dbwrap_util.c create mode 100644 lib/dbwrap/wscript_build delete mode 100644 source3/lib/dbwrap/dbwrap.c delete mode 100644 source3/lib/dbwrap/dbwrap.h delete mode 100644 source3/lib/dbwrap/dbwrap_cache.c delete mode 100644 source3/lib/dbwrap/dbwrap_cache.h delete mode 100644 source3/lib/dbwrap/dbwrap_file.c delete mode 100644 source3/lib/dbwrap/dbwrap_file.h delete mode 100644 source3/lib/dbwrap/dbwrap_private.h delete mode 100644 source3/lib/dbwrap/dbwrap_rbt.c delete mode 100644 source3/lib/dbwrap/dbwrap_rbt.h delete mode 100644 source3/lib/dbwrap/dbwrap_tdb.c delete mode 100644 source3/lib/dbwrap/dbwrap_tdb.h delete mode 100644 source3/lib/dbwrap/dbwrap_util.c diff --git a/lib/dbwrap/dbwrap.c b/lib/dbwrap/dbwrap.c new file mode 100644 index 0000000000..dbf10f7fb0 --- /dev/null +++ b/lib/dbwrap/dbwrap.c @@ -0,0 +1,398 @@ +/* + Unix SMB/CIFS implementation. + Database interface wrapper + Copyright (C) Jim McDonough 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 . +*/ + +#include "includes.h" +#include "dbwrap/dbwrap.h" +#include "dbwrap/dbwrap_private.h" +#include "lib/util/util_tdb.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; +} + + +/* + * 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) +{ + return rec->value; +} + +NTSTATUS dbwrap_record_store(struct db_record *rec, TDB_DATA data, int flags) +{ + NTSTATUS status; + struct db_context *db; + + status = rec->store(rec, data, flags); + if (!NT_STATUS_IS_OK(status)) { + return status; + } + db = rec->db; + if (db->stored_callback != NULL) { + db->stored_callback(db, rec, + db->stored_callback_private_data); + } + return NT_STATUS_OK; +} + +void dbwrap_set_stored_callback( + struct db_context *db, + void (*cb)(struct db_context *db, struct db_record *rec, + void *private_data), + void *private_data) +{ + db->stored_callback = cb; + db->stored_callback_private_data = private_data; +} + +NTSTATUS dbwrap_record_delete(struct db_record *rec) +{ + NTSTATUS status; + struct db_context *db; + + status = rec->delete_rec(rec); + if (!NT_STATUS_IS_OK(status)) { + return status; + } + db = rec->db; + if (db->stored_callback != NULL) { + db->stored_callback(db, rec, + db->stored_callback_private_data); + } + return NT_STATUS_OK; +} + +struct dbwrap_lock_order_state { + uint8_t *plock_order_mask; + uint8_t bitmask; +}; + +static int dbwrap_lock_order_state_destructor( + struct dbwrap_lock_order_state *s) +{ + *s->plock_order_mask &= ~s->bitmask; + return 0; +} + +static struct dbwrap_lock_order_state *dbwrap_check_lock_order( + struct db_context *db, TALLOC_CTX *mem_ctx) +{ + /* + * Store the lock_order of currently locked records as bits in + * "lock_order_mask". We only use levels 1,2,3 right now, so a + * single uint8_t is enough. + */ + static uint8_t lock_order_mask; + + struct dbwrap_lock_order_state *state; + uint8_t idx; + int used; + + if (db->lock_order == 0) { + /* + * lock order 0 is for example for dbwrap_rbt without + * real locking. Return state nevertheless to avoid + * special cases. + */ + return talloc(mem_ctx, struct dbwrap_lock_order_state); + } + + /* + * We fill bits from the high bits, to be able to use + * "ffs(lock_order_mask)" + */ + idx = sizeof(lock_order_mask)*8 - db->lock_order; + + used = ffs(lock_order_mask); + + DEBUG(5, ("used=%d, lock_order=%d, idx=%d\n", used, + (int)db->lock_order, (int)idx)); + + if ((used != 0) && (used-1 <= idx)) { + DEBUG(0, ("Lock order violation: Trying %d, order_mask=%x\n", + (int)db->lock_order, (int)lock_order_mask)); + return NULL; + } + + state = talloc(mem_ctx, struct dbwrap_lock_order_state); + if (state == NULL) { + DEBUG(1, ("talloc failed\n")); + return NULL; + } + state->bitmask = 1 << idx; + state->plock_order_mask = &lock_order_mask; + + talloc_set_destructor(state, dbwrap_lock_order_state_destructor); + lock_order_mask |= state->bitmask; + + 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; + TALLOC_CTX *frame = talloc_stackframe(); + + lock_order = dbwrap_check_lock_order(db, frame); + if (lock_order == NULL) { + TALLOC_FREE(frame); + return NULL; + } + rec = db_fn(db, mem_ctx, key); + if (rec == NULL) { + TALLOC_FREE(frame); + return NULL; + } + (void)talloc_steal(rec, lock_order); + rec->db = db; + TALLOC_FREE(frame); + 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_record *dbwrap_try_fetch_locked(struct db_context *db, + TALLOC_CTX *mem_ctx, + TDB_DATA key) +{ + return dbwrap_fetch_locked_internal( + db, mem_ctx, key, + db->try_fetch_locked + ? db->try_fetch_locked : 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); +} + +NTSTATUS dbwrap_store(struct db_context *db, TDB_DATA key, + TDB_DATA data, int flags) +{ + struct db_record *rec; + NTSTATUS status; + TALLOC_CTX *frame = talloc_stackframe(); + + rec = dbwrap_fetch_locked(db, frame, key); + if (rec == NULL) { + TALLOC_FREE(frame); + return NT_STATUS_NO_MEMORY; + } + + status = dbwrap_record_store(rec, data, flags); + TALLOC_FREE(frame); + return status; +} + +NTSTATUS dbwrap_delete(struct db_context *db, TDB_DATA key) +{ + struct db_record *rec; + NTSTATUS status; + TALLOC_CTX *frame = talloc_stackframe(); + + rec = dbwrap_fetch_locked(db, frame, key); + if (rec == NULL) { + TALLOC_FREE(frame); + return NT_STATUS_NO_MEMORY; + } + status = dbwrap_record_delete(rec); + TALLOC_FREE(frame); + return 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); +} + +int dbwrap_wipe(struct db_context *db) +{ + if (db->wipe == NULL) { + return dbwrap_fallback_wipe(db); + } + return db->wipe(db); +} + +int dbwrap_get_seqnum(struct db_context *db) +{ + return db->get_seqnum(db); +} + +int dbwrap_get_flags(struct db_context *db) +{ + return db->get_flags(db); +} + +int dbwrap_transaction_start(struct db_context *db) +{ + return db->transaction_start(db); +} + +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); +} + +void dbwrap_db_id(struct db_context *db, const uint8_t **id, size_t *idlen) +{ + db->id(db, id, idlen); +} diff --git a/lib/dbwrap/dbwrap.h b/lib/dbwrap/dbwrap.h new file mode 100644 index 0000000000..59e5af069e --- /dev/null +++ b/lib/dbwrap/dbwrap.h @@ -0,0 +1,131 @@ +/* + 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 . +*/ + +#ifndef __DBWRAP_H__ +#define __DBWRAP_H__ + +#include "tdb_compat.h" + +struct db_record; +struct db_context; + +enum dbwrap_lock_order { + DBWRAP_LOCK_ORDER_1 = 1, + DBWRAP_LOCK_ORDER_2 = 2, + DBWRAP_LOCK_ORDER_3 = 3 +}; + +/* 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_delete(struct db_record *rec); +struct db_record *dbwrap_fetch_locked(struct db_context *db, + TALLOC_CTX *mem_ctx, + TDB_DATA key); +struct db_record *dbwrap_try_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_set_stored_callback( + struct db_context *db, + void (*cb)(struct db_context *db, struct db_record *rec, + 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); +int dbwrap_wipe(struct db_context *db); +int dbwrap_get_seqnum(struct db_context *db); +int dbwrap_get_flags(struct db_context *db); +int dbwrap_transaction_start(struct db_context *db); +int dbwrap_transaction_commit(struct db_context *db); +int dbwrap_transaction_cancel(struct db_context *db); +void dbwrap_db_id(struct db_context *db, const uint8_t **id, size_t *idlen); + + +/* The following definitions come from lib/dbwrap_util.c */ + +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, const char *keystr, + int32_t *result); +NTSTATUS dbwrap_store_int32(struct db_context *db, const char *keystr, + int32_t v); +NTSTATUS dbwrap_fetch_uint32(struct db_context *db, const char *keystr, + uint32_t *val); +NTSTATUS dbwrap_store_uint32(struct db_context *db, const char *keystr, + uint32_t v); +NTSTATUS dbwrap_change_uint32_atomic(struct db_context *db, const char *keystr, + uint32_t *oldval, uint32_t change_val); +NTSTATUS dbwrap_trans_change_uint32_atomic(struct db_context *db, + const char *keystr, + uint32_t *oldval, + uint32_t change_val); +NTSTATUS dbwrap_change_int32_atomic(struct db_context *db, const char *keystr, + int32_t *oldval, int32_t change_val); +NTSTATUS dbwrap_trans_change_int32_atomic(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(struct db_context *db, const char *keystr, + int32_t v); +NTSTATUS dbwrap_trans_store_uint32(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); + +#endif /* __DBWRAP_H__ */ diff --git a/lib/dbwrap/dbwrap_cache.c b/lib/dbwrap/dbwrap_cache.c new file mode 100644 index 0000000000..865fcff7a1 --- /dev/null +++ b/lib/dbwrap/dbwrap_cache.c @@ -0,0 +1,225 @@ +/* + Unix SMB/CIFS implementation. + Cache db contents for parse_record based on seqnum + Copyright (C) Volker Lendecke 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 . +*/ + +#include "includes.h" +#include "lib/dbwrap/dbwrap.h" +#include "lib/dbwrap/dbwrap_private.h" +#include "lib/dbwrap/dbwrap_rbt.h" +#include "lib/dbwrap/dbwrap_cache.h" + +struct db_cache_ctx { + int seqnum; + struct db_context *backing; + struct db_context *positive; + struct db_context *negative; +}; + +static bool dbwrap_cache_validate(struct db_cache_ctx *ctx) +{ + if (ctx->seqnum == dbwrap_get_seqnum(ctx->backing)) { + return true; + } + TALLOC_FREE(ctx->positive); + ctx->positive = db_open_rbt(ctx); + TALLOC_FREE(ctx->negative); + ctx->negative = db_open_rbt(ctx); + + return ((ctx->positive != NULL) && (ctx->negative != NULL)); +} + +static NTSTATUS dbwrap_cache_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_cache_ctx *ctx = talloc_get_type_abort( + db->private_data, struct db_cache_ctx); + TDB_DATA value; + NTSTATUS status; + + if (!dbwrap_cache_validate(ctx)) { + return NT_STATUS_NO_MEMORY; + } + + status = dbwrap_parse_record(ctx->positive, key, parser, private_data); + if (NT_STATUS_IS_OK(status)) { + return status; + } + if (dbwrap_exists(ctx->negative, key)) { + return NT_STATUS_NOT_FOUND; + } + + status = dbwrap_fetch(ctx->backing, talloc_tos(), key, &value); + + if (NT_STATUS_IS_OK(status)) { + dbwrap_store(ctx->positive, key, value, 0); + parser(key, value, private_data); + TALLOC_FREE(value.dptr); + return NT_STATUS_OK; + } + + if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_FOUND)) { + char c = '\0'; + value.dptr = (uint8_t *)&c; + value.dsize = sizeof(c); + dbwrap_store(ctx->negative, key, value, 0); + return NT_STATUS_NOT_FOUND; + } + return status; +} + +static struct db_record *dbwrap_cache_fetch_locked( + struct db_context *db, TALLOC_CTX *mem_ctx, TDB_DATA key) +{ + struct db_cache_ctx *ctx = talloc_get_type_abort( + db->private_data, struct db_cache_ctx); + return dbwrap_fetch_locked(ctx->backing, mem_ctx, key); +} + +static int dbwrap_cache_traverse(struct db_context *db, + int (*f)(struct db_record *rec, + void *private_data), + void *private_data) +{ + struct db_cache_ctx *ctx = talloc_get_type_abort( + db->private_data, struct db_cache_ctx); + NTSTATUS status; + int ret; + status = dbwrap_traverse(ctx->backing, f, private_data, &ret); + if (!NT_STATUS_IS_OK(status)) { + return -1; + } + return ret; +} + +static int dbwrap_cache_traverse_read(struct db_context *db, + int (*f)(struct db_record *rec, + void *private_data), + void *private_data) +{ + struct db_cache_ctx *ctx = talloc_get_type_abort( + db->private_data, struct db_cache_ctx); + NTSTATUS status; + int ret; + status = dbwrap_traverse_read(ctx->backing, f, private_data, &ret); + if (!NT_STATUS_IS_OK(status)) { + return -1; + } + return ret; +} + +static int dbwrap_cache_get_seqnum(struct db_context *db) +{ + struct db_cache_ctx *ctx = talloc_get_type_abort( + db->private_data, struct db_cache_ctx); + return dbwrap_get_seqnum(ctx->backing); +} + +static int dbwrap_cache_get_flags(struct db_context *db) +{ + struct db_cache_ctx *ctx = talloc_get_type_abort( + db->private_data, struct db_cache_ctx); + return dbwrap_get_flags(ctx->backing); +} + +static int dbwrap_cache_transaction_start(struct db_context *db) +{ + struct db_cache_ctx *ctx = talloc_get_type_abort( + db->private_data, struct db_cache_ctx); + return dbwrap_transaction_start(ctx->backing); +} + +static int dbwrap_cache_transaction_commit(struct db_context *db) +{ + struct db_cache_ctx *ctx = talloc_get_type_abort( + db->private_data, struct db_cache_ctx); + return dbwrap_transaction_commit(ctx->backing); +} + +static int dbwrap_cache_transaction_cancel(struct db_context *db) +{ + struct db_cache_ctx *ctx = talloc_get_type_abort( + db->private_data, struct db_cache_ctx); + return dbwrap_transaction_cancel(ctx->backing); +} + +static int dbwrap_cache_exists(struct db_context *db, TDB_DATA key) +{ + struct db_cache_ctx *ctx = talloc_get_type_abort( + db->private_data, struct db_cache_ctx); + + if (ctx->positive && dbwrap_exists(ctx->positive, key)) { + return true; + } + if (ctx->negative && dbwrap_exists(ctx->negative, key)) { + return false; + } + return dbwrap_exists(ctx->backing, key); +} + +static void dbwrap_cache_id(struct db_context *db, const uint8_t **id, + size_t *idlen) +{ + struct db_cache_ctx *ctx = talloc_get_type_abort( + db->private_data, struct db_cache_ctx); + dbwrap_db_id(ctx->backing, id, idlen); +} + +struct db_context *db_open_cache(TALLOC_CTX *mem_ctx, + struct db_context *backing) +{ + struct db_context *db; + struct db_cache_ctx *ctx; + + db = talloc(mem_ctx, struct db_context); + if (db == NULL) { + return NULL; + } + ctx = talloc_zero(db, struct db_cache_ctx); + if (ctx == NULL) { + TALLOC_FREE(db); + return NULL; + } + + ctx->seqnum = -1; + ctx->backing = talloc_move(ctx, &backing); + db->private_data = ctx; + if (!dbwrap_cache_validate(ctx)) { + TALLOC_FREE(db); + return NULL; + } + + db->fetch_locked = dbwrap_cache_fetch_locked; + db->try_fetch_locked = NULL; + db->traverse = dbwrap_cache_traverse; + db->traverse_read = dbwrap_cache_traverse_read; + db->get_seqnum = dbwrap_cache_get_seqnum; + db->get_flags = dbwrap_cache_get_flags; + db->transaction_start = dbwrap_cache_transaction_start; + db->transaction_commit = dbwrap_cache_transaction_commit; + db->transaction_cancel = dbwrap_cache_transaction_cancel; + db->parse_record = dbwrap_cache_parse_record; + db->exists = dbwrap_cache_exists; + db->id = dbwrap_cache_id; + db->stored_callback = NULL; + db->wipe = NULL; + db->lock_order = 0; + db->persistent = false; + return db; +} diff --git a/lib/dbwrap/dbwrap_cache.h b/lib/dbwrap/dbwrap_cache.h new file mode 100644 index 0000000000..cd290e15f8 --- /dev/null +++ b/lib/dbwrap/dbwrap_cache.h @@ -0,0 +1,32 @@ +/* + Unix SMB/CIFS implementation. + Database interface wrapper around ctdbd + Copyright (C) Volker Lendecke 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 . +*/ + +#ifndef __DBWRAP_CACHE_H__ +#define __DBWRAP_CACHE_H__ + +#include + +#include "dbwrap/dbwrap_private.h" + +struct db_context; + +struct db_context *db_open_cache(TALLOC_CTX *mem_ctx, + struct db_context *backing); + +#endif /* __DBWRAP_CACHE_H__ */ diff --git a/lib/dbwrap/dbwrap_file.c b/lib/dbwrap/dbwrap_file.c new file mode 100644 index 0000000000..e0fd4ebc73 --- /dev/null +++ b/lib/dbwrap/dbwrap_file.c @@ -0,0 +1,418 @@ +/* + Unix SMB/CIFS implementation. + Database interface using a file per record + Copyright (C) Volker Lendecke 2005 + + 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 . +*/ + +#include "includes.h" +#include "dbwrap/dbwrap.h" +#include "dbwrap/dbwrap_file.h" +#include "dbwrap/dbwrap_private.h" +#include "lib/tdb_wrap/tdb_wrap.h" + +struct db_file_ctx { + const char *dirname; + + /* We only support one locked record at a time -- everything else + * would lead to a potential deadlock anyway! */ + struct db_record *locked_record; +}; + +struct db_locked_file { + int fd; + uint8_t hash; + const char *name; + const char *path; + struct db_file_ctx *parent; +}; + +/* Copy from statcache.c... */ + +static uint32_t fsh(const uint8_t *p, int len) +{ + uint32_t n = 0; + int i; + for (i=0; iparent != NULL) { + data->parent->locked_record = NULL; + } + + if (close(data->fd) != 0) { + DEBUG(3, ("close failed: %s\n", strerror(errno))); + return -1; + } + + return 0; +} + +static NTSTATUS db_file_store(struct db_record *rec, TDB_DATA data, int flag); +static NTSTATUS db_file_delete(struct db_record *rec); + +static struct db_record *db_file_fetch_locked(struct db_context *db, + TALLOC_CTX *mem_ctx, + TDB_DATA key) +{ + struct db_file_ctx *ctx = talloc_get_type_abort(db->private_data, + struct db_file_ctx); + struct db_record *result; + struct db_locked_file *file; + struct flock fl; + SMB_STRUCT_STAT statbuf; + int ret; + + SMB_ASSERT(ctx->locked_record == NULL); + + again: + if (!(result = talloc(mem_ctx, struct db_record))) { + DEBUG(0, ("talloc failed\n")); + return NULL; + } + + if (!(file = talloc(result, struct db_locked_file))) { + DEBUG(0, ("talloc failed\n")); + TALLOC_FREE(result); + return NULL; + } + + result->private_data = file; + result->store = db_file_store; + result->delete_rec = db_file_delete; + + result->key.dsize = key.dsize; + result->key.dptr = (uint8_t *)talloc_memdup(result, key.dptr, + key.dsize); + if (result->key.dptr == NULL) { + DEBUG(0, ("talloc failed\n")); + TALLOC_FREE(result); + return NULL; + } + + /* Cut to 8 bits */ + file->hash = fsh(key.dptr, key.dsize); + file->name = hex_encode_talloc(file, (unsigned char *)key.dptr, key.dsize); + if (file->name == NULL) { + DEBUG(0, ("hex_encode failed\n")); + TALLOC_FREE(result); + return NULL; + } + + file->path = talloc_asprintf(file, "%s/%2.2X/%s", ctx->dirname, + file->hash, file->name); + if (file->path == NULL) { + DEBUG(0, ("talloc_asprintf failed\n")); + TALLOC_FREE(result); + return NULL; + } + + become_root(); + file->fd = open(file->path, O_RDWR|O_CREAT, 0644); + unbecome_root(); + + if (file->fd < 0) { + DEBUG(3, ("Could not open/create %s: %s\n", + file->path, strerror(errno))); + TALLOC_FREE(result); + return NULL; + } + + talloc_set_destructor(file, db_locked_file_destr); + + fl.l_type = F_WRLCK; + fl.l_whence = SEEK_SET; + fl.l_start = 0; + fl.l_len = 1; + fl.l_pid = 0; + + do { + ret = fcntl(file->fd, F_SETLKW, &fl); + } while ((ret == -1) && (errno == EINTR)); + + if (ret == -1) { + DEBUG(3, ("Could not get lock on %s: %s\n", + file->path, strerror(errno))); + TALLOC_FREE(result); + return NULL; + } + + if (sys_fstat(file->fd, &statbuf, false) != 0) { + DEBUG(3, ("Could not fstat %s: %s\n", + file->path, strerror(errno))); + TALLOC_FREE(result); + return NULL; + } + + if (statbuf.st_ex_nlink == 0) { + /* Someone has deleted it under the lock, retry */ + TALLOC_FREE(result); + goto again; + } + + result->value.dsize = 0; + result->value.dptr = NULL; + + if (statbuf.st_ex_size != 0) { + NTSTATUS status; + + result->value.dsize = statbuf.st_ex_size; + result->value.dptr = talloc_array(result, uint8_t, + statbuf.st_ex_size); + if (result->value.dptr == NULL) { + DEBUG(1, ("talloc failed\n")); + TALLOC_FREE(result); + return NULL; + } + + status = read_data(file->fd, (char *)result->value.dptr, + result->value.dsize); + if (!NT_STATUS_IS_OK(status)) { + DEBUG(3, ("read_data failed: %s\n", + nt_errstr(status))); + TALLOC_FREE(result); + return NULL; + } + } + + ctx->locked_record = result; + file->parent = (struct db_file_ctx *)talloc_reference(file, ctx); + + return result; +} + +static NTSTATUS db_file_store_root(int fd, TDB_DATA data) +{ + if (lseek(fd, 0, SEEK_SET) != 0) { + DEBUG(0, ("lseek failed: %s\n", strerror(errno))); + return map_nt_error_from_unix(errno); + } + + if (write_data(fd, (char *)data.dptr, data.dsize) != data.dsize) { + DEBUG(3, ("write_data failed: %s\n", strerror(errno))); + return map_nt_error_from_unix(errno); + } + + if (ftruncate(fd, data.dsize) != 0) { + DEBUG(3, ("ftruncate failed: %s\n", strerror(errno))); + return map_nt_error_from_unix(errno); + } + + return NT_STATUS_OK; +} + +static NTSTATUS db_file_store(struct db_record *rec, TDB_DATA data, int flag) +{ + struct db_locked_file *file = + talloc_get_type_abort(rec->private_data, + struct db_locked_file); + NTSTATUS status; + + become_root(); + status = db_file_store_root(file->fd, data); + unbecome_root(); + + return status; +} + +static NTSTATUS db_file_delete(struct db_record *rec) +{ + struct db_locked_file *file = + talloc_get_type_abort(rec->private_data, + struct db_locked_file); + int res; + + become_root(); + res = unlink(file->path); + unbecome_root(); + + if (res == -1) { + DEBUG(3, ("unlink(%s) failed: %s\n", file->path, + strerror(errno))); + return map_nt_error_from_unix(errno); + } + + return NT_STATUS_OK; +} + +static int db_file_traverse(struct db_context *db, + int (*fn)(struct db_record *rec, + void *private_data), + void *private_data) +{ + struct db_file_ctx *ctx = talloc_get_type_abort(db->private_data, + struct db_file_ctx); + TALLOC_CTX *mem_ctx = talloc_init("traversal %s\n", ctx->dirname); + + int i; + int count = 0; + + for (i=0; i<256; i++) { + const char *dirname = talloc_asprintf(mem_ctx, "%s/%2.2X", + ctx->dirname, i); + DIR *dir; + struct dirent *dirent; + + if (dirname == NULL) { + DEBUG(0, ("talloc failed\n")); + TALLOC_FREE(mem_ctx); + return -1; + } + + dir = opendir(dirname); + if (dir == NULL) { + DEBUG(3, ("Could not open dir %s: %s\n", dirname, + strerror(errno))); + TALLOC_FREE(mem_ctx); + return -1; + } + + while ((dirent = readdir(dir)) != NULL) { + DATA_BLOB keyblob; + TDB_DATA key; + struct db_record *rec; + + if ((dirent->d_name[0] == '.') && + ((dirent->d_name[1] == '\0') || + ((dirent->d_name[1] == '.') && + (dirent->d_name[2] == '\0')))) { + continue; + } + + keyblob = strhex_to_data_blob(mem_ctx, dirent->d_name); + if (keyblob.data == NULL) { + DEBUG(5, ("strhex_to_data_blob failed\n")); + continue; + } + + key.dptr = keyblob.data; + key.dsize = keyblob.length; + + if ((ctx->locked_record != NULL) && + (key.dsize == ctx->locked_record->key.dsize) && + (memcmp(key.dptr, ctx->locked_record->key.dptr, + key.dsize) == 0)) { + count += 1; + if (fn(ctx->locked_record, + private_data) != 0) { + TALLOC_FREE(mem_ctx); + closedir(dir); + return count; + } + } + + rec = db_file_fetch_locked(db, mem_ctx, key); + if (rec == NULL) { + /* Someone might have deleted it */ + continue; + } + + if (rec->value.dptr == NULL) { + TALLOC_FREE(rec); + continue; + } + + count += 1; + + if (fn(rec, private_data) != 0) { + TALLOC_FREE(mem_ctx); + closedir(dir); + return count; + } + TALLOC_FREE(rec); + } + + closedir(dir); + } + + TALLOC_FREE(mem_ctx); + return count; +} + +struct db_context *db_open_file(TALLOC_CTX *mem_ctx, + struct messaging_context *msg_ctx, + const char *name, + int hash_size, int tdb_flags, + int open_flags, mode_t mode) +{ + struct db_context *result = NULL; + struct db_file_ctx *ctx; + + if (!(result = talloc_zero(mem_ctx, struct db_context))) { + DEBUG(0, ("talloc failed\n")); + return NULL; + } + + if (!(ctx = talloc(result, struct db_file_ctx))) { + DEBUG(0, ("talloc failed\n")); + TALLOC_FREE(result); + return NULL; + } + + result->private_data = ctx; + result->fetch_locked = db_file_fetch_locked; + result->try_fetch_locked = NULL; + result->traverse = db_file_traverse; + result->traverse_read = db_file_traverse; + result->persistent = ((tdb_flags & TDB_CLEAR_IF_FIRST) == 0); + + ctx->locked_record = NULL; + if (!(ctx->dirname = talloc_strdup(ctx, name))) { + DEBUG(0, ("talloc failed\n")); + TALLOC_FREE(result); + return NULL; + } + + if (open_flags & O_CREAT) { + int ret, i; + + mode |= (mode & S_IRUSR) ? S_IXUSR : 0; + mode |= (mode & S_IRGRP) ? S_IXGRP : 0; + mode |= (mode & S_IROTH) ? S_IXOTH : 0; + + ret = mkdir(name, mode); + if ((ret != 0) && (errno != EEXIST)) { + DEBUG(5, ("mkdir(%s,%o) failed: %s\n", name, mode, + strerror(errno))); + TALLOC_FREE(result); + return NULL; + } + + for (i=0; i<256; i++) { + char *path; + path = talloc_asprintf(result, "%s/%2.2X", name, i); + if (path == NULL) { + DEBUG(0, ("asprintf failed\n")); + TALLOC_FREE(result); + return NULL; + } + ret = mkdir(path, mode); + if ((ret != 0) && (errno != EEXIST)) { + DEBUG(5, ("mkdir(%s,%o) failed: %s\n", path, + mode, strerror(errno))); + TALLOC_FREE(result); + return NULL; + } + TALLOC_FREE(path); + } + } + + return result; +} diff --git a/lib/dbwrap/dbwrap_file.h b/lib/dbwrap/dbwrap_file.h new file mode 100644 index 0000000000..002f64dce5 --- /dev/null +++ b/lib/dbwrap/dbwrap_file.h @@ -0,0 +1,36 @@ +/* + Unix SMB/CIFS implementation. + Database interface using a file per record + Copyright (C) Volker Lendecke 2005 + + 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 . +*/ + +#ifndef __DBWRAP_FILE_H__ +#define __DBWRAP_FILE_H__ + +#include + +struct db_context; + +struct messaging_context; + +struct db_context *db_open_file(TALLOC_CTX *mem_ctx, + struct messaging_context *msg_ctx, + const char *name, + int hash_size, int tdb_flags, + int open_flags, mode_t mode); + + +#endif /* __DBWRAP_FILE_H__ */ diff --git a/lib/dbwrap/dbwrap_private.h b/lib/dbwrap/dbwrap_private.h new file mode 100644 index 0000000000..c197ffacf2 --- /dev/null +++ b/lib/dbwrap/dbwrap_private.h @@ -0,0 +1,70 @@ +/* + 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 . +*/ + +#ifndef __DBWRAP_PRIVATE_H__ +#define __DBWRAP_PRIVATE_H__ + +struct db_record { + struct db_context *db; + TDB_DATA key, value; + NTSTATUS (*store)(struct db_record *rec, TDB_DATA data, 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); + struct db_record *(*try_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 (*get_flags)(struct db_context *db); + int (*transaction_start)(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); + int (*exists)(struct db_context *db,TDB_DATA key); + int (*wipe)(struct db_context *db); + void (*id)(struct db_context *db, const uint8_t **id, size_t *idlen); + void *private_data; + enum dbwrap_lock_order lock_order; + bool persistent; + void (*stored_callback)(struct db_context *db, struct db_record *rec, + void *private_data); + void *stored_callback_private_data; +}; + +#endif /* __DBWRAP_PRIVATE_H__ */ + diff --git a/lib/dbwrap/dbwrap_rbt.c b/lib/dbwrap/dbwrap_rbt.c new file mode 100644 index 0000000000..c25ea6ec64 --- /dev/null +++ b/lib/dbwrap/dbwrap_rbt.c @@ -0,0 +1,450 @@ +/* + 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 . +*/ + +#include "includes.h" +#include "dbwrap/dbwrap.h" +#include "dbwrap/dbwrap_private.h" +#include "dbwrap/dbwrap_rbt.h" +#include "../lib/util/rbtree.h" + +#define DBWRAP_RBT_ALIGN(_size_) (((_size_)+15)&~15) + +struct db_rbt_ctx { + struct rb_root tree; +}; + +struct db_rbt_rec { + struct db_rbt_ctx *db_ctx; + 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; + + /* + * key and value are appended implicitly, "data" is only here as a + * target for offsetof() + */ + + char data[1]; +}; + +/* + * 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) +{ + key->dptr = ((uint8_t *)node) + offsetof(struct db_rbt_node, data); + key->dsize = node->keysize; + value->dptr = key->dptr + node->keysize; + value->dsize = node->valuesize; +} + +static NTSTATUS db_rbt_store(struct db_record *rec, TDB_DATA data, int flag) +{ + 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; + + TDB_DATA this_key, this_val; + + 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; + return NT_STATUS_OK; + } + + /* + * 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, &rec_priv->db_ctx->tree); + + /* + * Keep the existing node around for a while: If the record + * existed before, we reference the key data in there. + */ + } + + node = (struct db_rbt_node *)talloc_size(rec_priv->db_ctx, + offsetof(struct db_rbt_node, data) + rec->key.dsize + + data.dsize); + + if (node == NULL) { + TALLOC_FREE(rec_priv->node); + return NT_STATUS_NO_MEMORY; + } + + ZERO_STRUCT(node->rb_node); + + 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); + + memcpy(this_val.dptr, data.dptr, node->valuesize); + + parent = NULL; + p = &rec_priv->db_ctx->tree.rb_node; + + while (*p) { + struct db_rbt_node *r; + TDB_DATA search_key, search_val; + int res; + + parent = (*p); + + r = db_rbt2node(*p); + + 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); + rb_insert_color(&node->rb_node, &rec_priv->db_ctx->tree); + + return NT_STATUS_OK; +} + +static NTSTATUS db_rbt_delete(struct db_record *rec) +{ + struct db_rbt_rec *rec_priv = (struct db_rbt_rec *)rec->private_data; + + if (rec_priv->node == NULL) { + return NT_STATUS_OK; + } + + rb_erase(&rec_priv->node->rb_node, &rec_priv->db_ctx->tree); + 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, search_val; + + 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_ctx *ctx = talloc_get_type_abort( + db_ctx->private_data, struct db_rbt_ctx); + + 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))); + rec_priv->db_ctx = ctx; + + result->store = db_rbt_store; + result->delete_rec = db_rbt_delete; + result->private_data = rec_priv; + + rec_priv->node = res.node; + result->value = res.val; + + 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 rb_node *n, + int (*f)(struct db_record *db, + void *private_data), + void *private_data, uint32_t* count) +{ + struct db_rbt_node *r; + struct db_record rec; + int ret; + + if (n == NULL) { + return 0; + } + + ret = db_rbt_traverse_internal(n->rb_left, f, private_data, count); + if (ret != 0) { + return ret; + } + + r = db_rbt2node(n); + ZERO_STRUCT(rec); + db_rbt_parse_node(r, &rec.key, &rec.value); + + ret = f(&rec, private_data); + (*count) ++; + if (ret != 0) { + return ret; + } + + return db_rbt_traverse_internal(n->rb_right, f, private_data, 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 = db_rbt_traverse_internal(ctx->tree.rb_node, f, private_data, &count); + 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 void db_rbt_id(struct db_context *db, const uint8_t **id, size_t *idlen) +{ + *id = (uint8_t *)db; + *idlen = sizeof(db); +} + +struct db_context *db_open_rbt(TALLOC_CTX *mem_ctx) +{ + struct db_context *result; + + result = talloc(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->try_fetch_locked = NULL; + result->traverse = db_rbt_traverse; + result->traverse_read = db_rbt_traverse; + 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->lock_order = 0; + result->id = db_rbt_id; + result->stored_callback = NULL; + + return result; +} diff --git a/lib/dbwrap/dbwrap_rbt.h b/lib/dbwrap/dbwrap_rbt.h new file mode 100644 index 0000000000..1716879de6 --- /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 . +*/ + +#ifndef __DBWRAP_RBT_H__ +#define __DBWRAP_RBT_H__ + +#include + +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 0000000000..398d41a7db --- /dev/null +++ b/lib/dbwrap/dbwrap_tdb.c @@ -0,0 +1,447 @@ +/* + 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 . +*/ + +#include "includes.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 "system/filesys.h" + +struct db_tdb_ctx { + struct tdb_wrap *wtdb; + + struct { + dev_t dev; + ino_t ino; + } id; +}; + +static NTSTATUS db_tdb_store(struct db_record *rec, TDB_DATA data, int flag); +static NTSTATUS db_tdb_delete(struct db_record *rec); + +static void db_tdb_log_key(const char *prefix, TDB_DATA key) +{ + size_t len; + char *keystr; + + if (DEBUGLEVEL < 10) { + return; + } + len = key.dsize; + if (DEBUGLEVEL == 10) { + /* + * Only fully spam at debuglevel > 10 + */ + len = MIN(10, key.dsize); + } + keystr = hex_encode_talloc(talloc_tos(), (unsigned char *)(key.dptr), + len); + DEBUG(10, ("%s key %s\n", prefix, keystr)); + TALLOC_FREE(keystr); +} + +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; + } + + return 0; +} + +static struct db_record *db_tdb_fetch_locked_internal( + 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); + struct tdb_fetch_locked_state state; + + state.mem_ctx = mem_ctx; + state.result = NULL; + + if ((tdb_parse_record(ctx->wtdb->tdb, key, db_tdb_fetchlock_parse, + &state) < 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 = talloc_reference(state.result, ctx); + state.result->store = db_tdb_store; + state.result->delete_rec = db_tdb_delete; + + DEBUG(10, ("Allocated locked data 0x%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, mem_ctx, key); +} + +static struct db_record *db_tdb_try_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("Trying to lock", key); + if (tdb_chainlock_nonblock(ctx->wtdb->tdb, key) != 0) { + DEBUG(3, ("tdb_chainlock_nonblock failed\n")); + return NULL; + } + return db_tdb_fetch_locked_internal(db, mem_ctx, key); +} + + +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); +} + +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_store(struct db_record *rec, TDB_DATA data, int flag) +{ + struct db_tdb_ctx *ctx = talloc_get_type_abort(rec->private_data, + struct db_tdb_ctx); + + /* + * 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. + */ + + return (tdb_store(ctx->wtdb->tdb, rec->key, data, flag) == 0) ? + NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL; +} + +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.store = db_tdb_store; + 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_store_deny(struct db_record *rec, TDB_DATA data, 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.store = db_tdb_store_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_get_flags(struct db_context *db) + +{ + struct db_tdb_ctx *db_ctx = + talloc_get_type_abort(db->private_data, struct db_tdb_ctx); + return tdb_get_flags(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 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 void db_tdb_id(struct db_context *db, const uint8_t **id, size_t *idlen) +{ + struct db_tdb_ctx *db_ctx = + talloc_get_type_abort(db->private_data, struct db_tdb_ctx); + *id = (uint8_t *)&db_ctx->id; + *idlen = sizeof(db_ctx->id); +} + +struct db_context *db_open_tdb(TALLOC_CTX *mem_ctx, + struct loadparm_context *lp_ctx, + const char *name, + int hash_size, int tdb_flags, + int open_flags, mode_t mode, + enum dbwrap_lock_order lock_order) +{ + 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, lp_ctx); + 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->try_fetch_locked = db_tdb_try_fetch_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->get_flags = db_tdb_get_flags; + result->persistent = ((tdb_flags & TDB_CLEAR_IF_FIRST) == 0); + result->transaction_start = db_tdb_transaction_start; + 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->stored_callback = NULL; + return result; + + fail: + if (result != NULL) { + TALLOC_FREE(result); + } + return NULL; +} diff --git a/lib/dbwrap/dbwrap_tdb.h b/lib/dbwrap/dbwrap_tdb.h new file mode 100644 index 0000000000..6a6da45a08 --- /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 . +*/ + +#ifndef __DBWRAP_TDB_H__ +#define __DBWRAP_TDB_H__ + +#include + +struct db_context; + +struct db_context *db_open_tdb(TALLOC_CTX *mem_ctx, + struct loadparm_context *lp_ctx, + const char *name, + int hash_size, int tdb_flags, + int open_flags, mode_t mode, + enum dbwrap_lock_order lock_order); + + +#endif /* __DBWRAP_TDB_H__ */ diff --git a/lib/dbwrap/dbwrap_util.c b/lib/dbwrap/dbwrap_util.c new file mode 100644 index 0000000000..9a65f7abe9 --- /dev/null +++ b/lib/dbwrap/dbwrap_util.c @@ -0,0 +1,539 @@ +/* + Unix SMB/CIFS implementation. + Utility functions for the dbwrap API + Copyright (C) Volker Lendecke 2007 + Copyright (C) Michael Adam 2009 + Copyright (C) Jim McDonough 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" + +NTSTATUS dbwrap_fetch_int32(struct db_context *db, const char *keystr, + int32_t *result) +{ + TDB_DATA dbuf; + NTSTATUS status; + + if (result == NULL) { + return NT_STATUS_INVALID_PARAMETER; + } + + status = dbwrap_fetch_bystring(db, NULL, keystr, &dbuf); + if (!NT_STATUS_IS_OK(status)) { + return status; + } + + if ((dbuf.dptr == NULL) || (dbuf.dsize != sizeof(int32_t))) { + TALLOC_FREE(dbuf.dptr); + return NT_STATUS_NOT_FOUND; + } + + *result = IVAL(dbuf.dptr, 0); + TALLOC_FREE(dbuf.dptr); + return NT_STATUS_OK; +} + +NTSTATUS dbwrap_store_int32(struct db_context *db, const char *keystr, + int32_t v) +{ + struct db_record *rec; + int32_t v_store; + NTSTATUS status; + + rec = dbwrap_fetch_locked(db, NULL, string_term_tdb_data(keystr)); + if (rec == NULL) { + return NT_STATUS_UNSUCCESSFUL; + } + + SIVAL(&v_store, 0, v); + + status = dbwrap_record_store(rec, + make_tdb_data((const uint8_t *)&v_store, + sizeof(v_store)), + TDB_REPLACE); + TALLOC_FREE(rec); + return status; +} + +NTSTATUS dbwrap_fetch_uint32(struct db_context *db, const char *keystr, + uint32_t *val) +{ + TDB_DATA dbuf; + NTSTATUS status; + + if (val == NULL) { + return NT_STATUS_INVALID_PARAMETER; + } + + status = dbwrap_fetch_bystring(db, NULL, keystr, &dbuf); + if (!NT_STATUS_IS_OK(status)) { + return status; + } + + if ((dbuf.dptr == NULL) || (dbuf.dsize != sizeof(uint32_t))) { + TALLOC_FREE(dbuf.dptr); + return NT_STATUS_NOT_FOUND; + } + + *val = IVAL(dbuf.dptr, 0); + TALLOC_FREE(dbuf.dptr); + return NT_STATUS_OK; +} + +NTSTATUS dbwrap_store_uint32(struct db_context *db, const char *keystr, + uint32_t v) +{ + struct db_record *rec; + uint32_t v_store; + NTSTATUS status; + + rec = dbwrap_fetch_locked(db, NULL, string_term_tdb_data(keystr)); + if (rec == NULL) { + return NT_STATUS_INVALID_PARAMETER; + } + + SIVAL(&v_store, 0, v); + + status = dbwrap_record_store(rec, + make_tdb_data((const uint8_t *)&v_store, + sizeof(v_store)), + TDB_REPLACE); + TALLOC_FREE(rec); + 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, NULL, 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(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(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 { + const char *keystr; + 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, NULL, 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_int32_atomic(struct db_context *db, const char *keystr, + int32_t *oldval, int32_t change_val) +{ + NTSTATUS ret; + struct dbwrap_change_int32_atomic_context state; + + state.keystr = keystr; + state.oldval = oldval; + state.change_val = change_val; + + ret = dbwrap_change_int32_atomic_action(db, &state); + + return ret; +} + +NTSTATUS dbwrap_trans_change_int32_atomic(struct db_context *db, + const char *keystr, + int32_t *oldval, + int32_t change_val) +{ + NTSTATUS ret; + struct dbwrap_change_int32_atomic_context state; + + state.keystr = 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) +{ + struct db_record *rec = NULL; + NTSTATUS status; + struct dbwrap_store_context *store_ctx; + + store_ctx = (struct dbwrap_store_context *)private_data; + + rec = dbwrap_fetch_locked(db, talloc_tos(), *(store_ctx->key)); + if (rec == NULL) { + DEBUG(5, ("fetch_locked failed\n")); + return NT_STATUS_NO_MEMORY; + } + + status = dbwrap_record_store(rec, *(store_ctx->dbuf), store_ctx->flag); + if (!NT_STATUS_IS_OK(status)) { + DEBUG(5, ("store returned %s\n", nt_errstr(status))); + } + + TALLOC_FREE(rec); + 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; + struct db_record *rec; + TDB_DATA *key = (TDB_DATA *)private_data; + + rec = dbwrap_fetch_locked(db, talloc_tos(), *key); + if (rec == NULL) { + DEBUG(5, ("fetch_locked failed\n")); + return NT_STATUS_NO_MEMORY; + } + + status = dbwrap_record_delete(rec); + if (!NT_STATUS_IS_OK(status)) { + DEBUG(5, ("delete_rec returned %s\n", nt_errstr(status))); + } + + talloc_free(rec); + 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(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(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_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; +} diff --git a/lib/dbwrap/wscript_build b/lib/dbwrap/wscript_build new file mode 100644 index 0000000000..d172efbb6e --- /dev/null +++ b/lib/dbwrap/wscript_build @@ -0,0 +1,11 @@ +bld.SAMBA_LIBRARY('dbwrap', + source=''' + dbwrap.c + dbwrap_util.c + dbwrap_rbt.c + dbwrap_cache.c + dbwrap_tdb.c + ''', + deps='samba-util util_tdb errors tdb tdb-wrap', + private_library=True) + diff --git a/source3/Makefile.in b/source3/Makefile.in index 5a7444bd9c..92207781ce 100644 --- a/source3/Makefile.in +++ b/source3/Makefile.in @@ -257,15 +257,15 @@ EXTRA_ALL_TARGETS = @EXTRA_ALL_TARGETS@ TDB_LIB_OBJ = lib/util_tdb.o ../lib/util/util_tdb.o \ ../lib/tdb_wrap/tdb_wrap.o \ - lib/dbwrap/dbwrap.o \ + ../lib/dbwrap/dbwrap.o \ lib/dbwrap/dbwrap_open.o \ - lib/dbwrap/dbwrap_tdb.o \ + ../lib/dbwrap/dbwrap_tdb.o \ lib/dbwrap/dbwrap_ctdb.o \ lib/g_lock.o \ - lib/dbwrap/dbwrap_cache.o \ + ../lib/dbwrap/dbwrap_cache.o \ lib/dbwrap/dbwrap_watch.o \ - lib/dbwrap/dbwrap_rbt.o \ - lib/dbwrap/dbwrap_util.o + ../lib/dbwrap/dbwrap_rbt.o \ + ../lib/dbwrap/dbwrap_util.o TDB_VALIDATE_OBJ = lib/tdb_validate.o diff --git a/source3/lib/dbwrap/dbwrap.c b/source3/lib/dbwrap/dbwrap.c deleted file mode 100644 index 14562bb6e4..0000000000 --- a/source3/lib/dbwrap/dbwrap.c +++ /dev/null @@ -1,398 +0,0 @@ -/* - Unix SMB/CIFS implementation. - Database interface wrapper - Copyright (C) Jim McDonough 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 . -*/ - -#include "includes.h" -#include "dbwrap/dbwrap.h" -#include "dbwrap/dbwrap_private.h" -#include "util_tdb.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; -} - - -/* - * 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) -{ - return rec->value; -} - -NTSTATUS dbwrap_record_store(struct db_record *rec, TDB_DATA data, int flags) -{ - NTSTATUS status; - struct db_context *db; - - status = rec->store(rec, data, flags); - if (!NT_STATUS_IS_OK(status)) { - return status; - } - db = rec->db; - if (db->stored_callback != NULL) { - db->stored_callback(db, rec, - db->stored_callback_private_data); - } - return NT_STATUS_OK; -} - -void dbwrap_set_stored_callback( - struct db_context *db, - void (*cb)(struct db_context *db, struct db_record *rec, - void *private_data), - void *private_data) -{ - db->stored_callback = cb; - db->stored_callback_private_data = private_data; -} - -NTSTATUS dbwrap_record_delete(struct db_record *rec) -{ - NTSTATUS status; - struct db_context *db; - - status = rec->delete_rec(rec); - if (!NT_STATUS_IS_OK(status)) { - return status; - } - db = rec->db; - if (db->stored_callback != NULL) { - db->stored_callback(db, rec, - db->stored_callback_private_data); - } - return NT_STATUS_OK; -} - -struct dbwrap_lock_order_state { - uint8_t *plock_order_mask; - uint8_t bitmask; -}; - -static int dbwrap_lock_order_state_destructor( - struct dbwrap_lock_order_state *s) -{ - *s->plock_order_mask &= ~s->bitmask; - return 0; -} - -static struct dbwrap_lock_order_state *dbwrap_check_lock_order( - struct db_context *db, TALLOC_CTX *mem_ctx) -{ - /* - * Store the lock_order of currently locked records as bits in - * "lock_order_mask". We only use levels 1,2,3 right now, so a - * single uint8_t is enough. - */ - static uint8_t lock_order_mask; - - struct dbwrap_lock_order_state *state; - uint8_t idx; - int used; - - if (db->lock_order == 0) { - /* - * lock order 0 is for example for dbwrap_rbt without - * real locking. Return state nevertheless to avoid - * special cases. - */ - return talloc(mem_ctx, struct dbwrap_lock_order_state); - } - - /* - * We fill bits from the high bits, to be able to use - * "ffs(lock_order_mask)" - */ - idx = sizeof(lock_order_mask)*8 - db->lock_order; - - used = ffs(lock_order_mask); - - DEBUG(5, ("used=%d, lock_order=%d, idx=%d\n", used, - (int)db->lock_order, (int)idx)); - - if ((used != 0) && (used-1 <= idx)) { - DEBUG(0, ("Lock order violation: Trying %d, order_mask=%x\n", - (int)db->lock_order, (int)lock_order_mask)); - return NULL; - } - - state = talloc(mem_ctx, struct dbwrap_lock_order_state); - if (state == NULL) { - DEBUG(1, ("talloc failed\n")); - return NULL; - } - state->bitmask = 1 << idx; - state->plock_order_mask = &lock_order_mask; - - talloc_set_destructor(state, dbwrap_lock_order_state_destructor); - lock_order_mask |= state->bitmask; - - 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; - TALLOC_CTX *frame = talloc_stackframe(); - - lock_order = dbwrap_check_lock_order(db, frame); - if (lock_order == NULL) { - TALLOC_FREE(frame); - return NULL; - } - rec = db_fn(db, mem_ctx, key); - if (rec == NULL) { - TALLOC_FREE(frame); - return NULL; - } - (void)talloc_steal(rec, lock_order); - rec->db = db; - TALLOC_FREE(frame); - 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_record *dbwrap_try_fetch_locked(struct db_context *db, - TALLOC_CTX *mem_ctx, - TDB_DATA key) -{ - return dbwrap_fetch_locked_internal( - db, mem_ctx, key, - db->try_fetch_locked - ? db->try_fetch_locked : 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); -} - -NTSTATUS dbwrap_store(struct db_context *db, TDB_DATA key, - TDB_DATA data, int flags) -{ - struct db_record *rec; - NTSTATUS status; - TALLOC_CTX *frame = talloc_stackframe(); - - rec = dbwrap_fetch_locked(db, frame, key); - if (rec == NULL) { - TALLOC_FREE(frame); - return NT_STATUS_NO_MEMORY; - } - - status = dbwrap_record_store(rec, data, flags); - TALLOC_FREE(frame); - return status; -} - -NTSTATUS dbwrap_delete(struct db_context *db, TDB_DATA key) -{ - struct db_record *rec; - NTSTATUS status; - TALLOC_CTX *frame = talloc_stackframe(); - - rec = dbwrap_fetch_locked(db, frame, key); - if (rec == NULL) { - TALLOC_FREE(frame); - return NT_STATUS_NO_MEMORY; - } - status = dbwrap_record_delete(rec); - TALLOC_FREE(frame); - return 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); -} - -int dbwrap_wipe(struct db_context *db) -{ - if (db->wipe == NULL) { - return dbwrap_fallback_wipe(db); - } - return db->wipe(db); -} - -int dbwrap_get_seqnum(struct db_context *db) -{ - return db->get_seqnum(db); -} - -int dbwrap_get_flags(struct db_context *db) -{ - return db->get_flags(db); -} - -int dbwrap_transaction_start(struct db_context *db) -{ - return db->transaction_start(db); -} - -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); -} - -void dbwrap_db_id(struct db_context *db, const uint8_t **id, size_t *idlen) -{ - db->id(db, id, idlen); -} diff --git a/source3/lib/dbwrap/dbwrap.h b/source3/lib/dbwrap/dbwrap.h deleted file mode 100644 index 59e5af069e..0000000000 --- a/source3/lib/dbwrap/dbwrap.h +++ /dev/null @@ -1,131 +0,0 @@ -/* - 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 . -*/ - -#ifndef __DBWRAP_H__ -#define __DBWRAP_H__ - -#include "tdb_compat.h" - -struct db_record; -struct db_context; - -enum dbwrap_lock_order { - DBWRAP_LOCK_ORDER_1 = 1, - DBWRAP_LOCK_ORDER_2 = 2, - DBWRAP_LOCK_ORDER_3 = 3 -}; - -/* 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_delete(struct db_record *rec); -struct db_record *dbwrap_fetch_locked(struct db_context *db, - TALLOC_CTX *mem_ctx, - TDB_DATA key); -struct db_record *dbwrap_try_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_set_stored_callback( - struct db_context *db, - void (*cb)(struct db_context *db, struct db_record *rec, - 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); -int dbwrap_wipe(struct db_context *db); -int dbwrap_get_seqnum(struct db_context *db); -int dbwrap_get_flags(struct db_context *db); -int dbwrap_transaction_start(struct db_context *db); -int dbwrap_transaction_commit(struct db_context *db); -int dbwrap_transaction_cancel(struct db_context *db); -void dbwrap_db_id(struct db_context *db, const uint8_t **id, size_t *idlen); - - -/* The following definitions come from lib/dbwrap_util.c */ - -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, const char *keystr, - int32_t *result); -NTSTATUS dbwrap_store_int32(struct db_context *db, const char *keystr, - int32_t v); -NTSTATUS dbwrap_fetch_uint32(struct db_context *db, const char *keystr, - uint32_t *val); -NTSTATUS dbwrap_store_uint32(struct db_context *db, const char *keystr, - uint32_t v); -NTSTATUS dbwrap_change_uint32_atomic(struct db_context *db, const char *keystr, - uint32_t *oldval, uint32_t change_val); -NTSTATUS dbwrap_trans_change_uint32_atomic(struct db_context *db, - const char *keystr, - uint32_t *oldval, - uint32_t change_val); -NTSTATUS dbwrap_change_int32_atomic(struct db_context *db, const char *keystr, - int32_t *oldval, int32_t change_val); -NTSTATUS dbwrap_trans_change_int32_atomic(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(struct db_context *db, const char *keystr, - int32_t v); -NTSTATUS dbwrap_trans_store_uint32(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); - -#endif /* __DBWRAP_H__ */ diff --git a/source3/lib/dbwrap/dbwrap_cache.c b/source3/lib/dbwrap/dbwrap_cache.c deleted file mode 100644 index 865fcff7a1..0000000000 --- a/source3/lib/dbwrap/dbwrap_cache.c +++ /dev/null @@ -1,225 +0,0 @@ -/* - Unix SMB/CIFS implementation. - Cache db contents for parse_record based on seqnum - Copyright (C) Volker Lendecke 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 . -*/ - -#include "includes.h" -#include "lib/dbwrap/dbwrap.h" -#include "lib/dbwrap/dbwrap_private.h" -#include "lib/dbwrap/dbwrap_rbt.h" -#include "lib/dbwrap/dbwrap_cache.h" - -struct db_cache_ctx { - int seqnum; - struct db_context *backing; - struct db_context *positive; - struct db_context *negative; -}; - -static bool dbwrap_cache_validate(struct db_cache_ctx *ctx) -{ - if (ctx->seqnum == dbwrap_get_seqnum(ctx->backing)) { - return true; - } - TALLOC_FREE(ctx->positive); - ctx->positive = db_open_rbt(ctx); - TALLOC_FREE(ctx->negative); - ctx->negative = db_open_rbt(ctx); - - return ((ctx->positive != NULL) && (ctx->negative != NULL)); -} - -static NTSTATUS dbwrap_cache_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_cache_ctx *ctx = talloc_get_type_abort( - db->private_data, struct db_cache_ctx); - TDB_DATA value; - NTSTATUS status; - - if (!dbwrap_cache_validate(ctx)) { - return NT_STATUS_NO_MEMORY; - } - - status = dbwrap_parse_record(ctx->positive, key, parser, private_data); - if (NT_STATUS_IS_OK(status)) { - return status; - } - if (dbwrap_exists(ctx->negative, key)) { - return NT_STATUS_NOT_FOUND; - } - - status = dbwrap_fetch(ctx->backing, talloc_tos(), key, &value); - - if (NT_STATUS_IS_OK(status)) { - dbwrap_store(ctx->positive, key, value, 0); - parser(key, value, private_data); - TALLOC_FREE(value.dptr); - return NT_STATUS_OK; - } - - if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_FOUND)) { - char c = '\0'; - value.dptr = (uint8_t *)&c; - value.dsize = sizeof(c); - dbwrap_store(ctx->negative, key, value, 0); - return NT_STATUS_NOT_FOUND; - } - return status; -} - -static struct db_record *dbwrap_cache_fetch_locked( - struct db_context *db, TALLOC_CTX *mem_ctx, TDB_DATA key) -{ - struct db_cache_ctx *ctx = talloc_get_type_abort( - db->private_data, struct db_cache_ctx); - return dbwrap_fetch_locked(ctx->backing, mem_ctx, key); -} - -static int dbwrap_cache_traverse(struct db_context *db, - int (*f)(struct db_record *rec, - void *private_data), - void *private_data) -{ - struct db_cache_ctx *ctx = talloc_get_type_abort( - db->private_data, struct db_cache_ctx); - NTSTATUS status; - int ret; - status = dbwrap_traverse(ctx->backing, f, private_data, &ret); - if (!NT_STATUS_IS_OK(status)) { - return -1; - } - return ret; -} - -static int dbwrap_cache_traverse_read(struct db_context *db, - int (*f)(struct db_record *rec, - void *private_data), - void *private_data) -{ - struct db_cache_ctx *ctx = talloc_get_type_abort( - db->private_data, struct db_cache_ctx); - NTSTATUS status; - int ret; - status = dbwrap_traverse_read(ctx->backing, f, private_data, &ret); - if (!NT_STATUS_IS_OK(status)) { - return -1; - } - return ret; -} - -static int dbwrap_cache_get_seqnum(struct db_context *db) -{ - struct db_cache_ctx *ctx = talloc_get_type_abort( - db->private_data, struct db_cache_ctx); - return dbwrap_get_seqnum(ctx->backing); -} - -static int dbwrap_cache_get_flags(struct db_context *db) -{ - struct db_cache_ctx *ctx = talloc_get_type_abort( - db->private_data, struct db_cache_ctx); - return dbwrap_get_flags(ctx->backing); -} - -static int dbwrap_cache_transaction_start(struct db_context *db) -{ - struct db_cache_ctx *ctx = talloc_get_type_abort( - db->private_data, struct db_cache_ctx); - return dbwrap_transaction_start(ctx->backing); -} - -static int dbwrap_cache_transaction_commit(struct db_context *db) -{ - struct db_cache_ctx *ctx = talloc_get_type_abort( - db->private_data, struct db_cache_ctx); - return dbwrap_transaction_commit(ctx->backing); -} - -static int dbwrap_cache_transaction_cancel(struct db_context *db) -{ - struct db_cache_ctx *ctx = talloc_get_type_abort( - db->private_data, struct db_cache_ctx); - return dbwrap_transaction_cancel(ctx->backing); -} - -static int dbwrap_cache_exists(struct db_context *db, TDB_DATA key) -{ - struct db_cache_ctx *ctx = talloc_get_type_abort( - db->private_data, struct db_cache_ctx); - - if (ctx->positive && dbwrap_exists(ctx->positive, key)) { - return true; - } - if (ctx->negative && dbwrap_exists(ctx->negative, key)) { - return false; - } - return dbwrap_exists(ctx->backing, key); -} - -static void dbwrap_cache_id(struct db_context *db, const uint8_t **id, - size_t *idlen) -{ - struct db_cache_ctx *ctx = talloc_get_type_abort( - db->private_data, struct db_cache_ctx); - dbwrap_db_id(ctx->backing, id, idlen); -} - -struct db_context *db_open_cache(TALLOC_CTX *mem_ctx, - struct db_context *backing) -{ - struct db_context *db; - struct db_cache_ctx *ctx; - - db = talloc(mem_ctx, struct db_context); - if (db == NULL) { - return NULL; - } - ctx = talloc_zero(db, struct db_cache_ctx); - if (ctx == NULL) { - TALLOC_FREE(db); - return NULL; - } - - ctx->seqnum = -1; - ctx->backing = talloc_move(ctx, &backing); - db->private_data = ctx; - if (!dbwrap_cache_validate(ctx)) { - TALLOC_FREE(db); - return NULL; - } - - db->fetch_locked = dbwrap_cache_fetch_locked; - db->try_fetch_locked = NULL; - db->traverse = dbwrap_cache_traverse; - db->traverse_read = dbwrap_cache_traverse_read; - db->get_seqnum = dbwrap_cache_get_seqnum; - db->get_flags = dbwrap_cache_get_flags; - db->transaction_start = dbwrap_cache_transaction_start; - db->transaction_commit = dbwrap_cache_transaction_commit; - db->transaction_cancel = dbwrap_cache_transaction_cancel; - db->parse_record = dbwrap_cache_parse_record; - db->exists = dbwrap_cache_exists; - db->id = dbwrap_cache_id; - db->stored_callback = NULL; - db->wipe = NULL; - db->lock_order = 0; - db->persistent = false; - return db; -} diff --git a/source3/lib/dbwrap/dbwrap_cache.h b/source3/lib/dbwrap/dbwrap_cache.h deleted file mode 100644 index cd290e15f8..0000000000 --- a/source3/lib/dbwrap/dbwrap_cache.h +++ /dev/null @@ -1,32 +0,0 @@ -/* - Unix SMB/CIFS implementation. - Database interface wrapper around ctdbd - Copyright (C) Volker Lendecke 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 . -*/ - -#ifndef __DBWRAP_CACHE_H__ -#define __DBWRAP_CACHE_H__ - -#include - -#include "dbwrap/dbwrap_private.h" - -struct db_context; - -struct db_context *db_open_cache(TALLOC_CTX *mem_ctx, - struct db_context *backing); - -#endif /* __DBWRAP_CACHE_H__ */ diff --git a/source3/lib/dbwrap/dbwrap_file.c b/source3/lib/dbwrap/dbwrap_file.c deleted file mode 100644 index e0fd4ebc73..0000000000 --- a/source3/lib/dbwrap/dbwrap_file.c +++ /dev/null @@ -1,418 +0,0 @@ -/* - Unix SMB/CIFS implementation. - Database interface using a file per record - Copyright (C) Volker Lendecke 2005 - - 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 . -*/ - -#include "includes.h" -#include "dbwrap/dbwrap.h" -#include "dbwrap/dbwrap_file.h" -#include "dbwrap/dbwrap_private.h" -#include "lib/tdb_wrap/tdb_wrap.h" - -struct db_file_ctx { - const char *dirname; - - /* We only support one locked record at a time -- everything else - * would lead to a potential deadlock anyway! */ - struct db_record *locked_record; -}; - -struct db_locked_file { - int fd; - uint8_t hash; - const char *name; - const char *path; - struct db_file_ctx *parent; -}; - -/* Copy from statcache.c... */ - -static uint32_t fsh(const uint8_t *p, int len) -{ - uint32_t n = 0; - int i; - for (i=0; iparent != NULL) { - data->parent->locked_record = NULL; - } - - if (close(data->fd) != 0) { - DEBUG(3, ("close failed: %s\n", strerror(errno))); - return -1; - } - - return 0; -} - -static NTSTATUS db_file_store(struct db_record *rec, TDB_DATA data, int flag); -static NTSTATUS db_file_delete(struct db_record *rec); - -static struct db_record *db_file_fetch_locked(struct db_context *db, - TALLOC_CTX *mem_ctx, - TDB_DATA key) -{ - struct db_file_ctx *ctx = talloc_get_type_abort(db->private_data, - struct db_file_ctx); - struct db_record *result; - struct db_locked_file *file; - struct flock fl; - SMB_STRUCT_STAT statbuf; - int ret; - - SMB_ASSERT(ctx->locked_record == NULL); - - again: - if (!(result = talloc(mem_ctx, struct db_record))) { - DEBUG(0, ("talloc failed\n")); - return NULL; - } - - if (!(file = talloc(result, struct db_locked_file))) { - DEBUG(0, ("talloc failed\n")); - TALLOC_FREE(result); - return NULL; - } - - result->private_data = file; - result->store = db_file_store; - result->delete_rec = db_file_delete; - - result->key.dsize = key.dsize; - result->key.dptr = (uint8_t *)talloc_memdup(result, key.dptr, - key.dsize); - if (result->key.dptr == NULL) { - DEBUG(0, ("talloc failed\n")); - TALLOC_FREE(result); - return NULL; - } - - /* Cut to 8 bits */ - file->hash = fsh(key.dptr, key.dsize); - file->name = hex_encode_talloc(file, (unsigned char *)key.dptr, key.dsize); - if (file->name == NULL) { - DEBUG(0, ("hex_encode failed\n")); - TALLOC_FREE(result); - return NULL; - } - - file->path = talloc_asprintf(file, "%s/%2.2X/%s", ctx->dirname, - file->hash, file->name); - if (file->path == NULL) { - DEBUG(0, ("talloc_asprintf failed\n")); - TALLOC_FREE(result); - return NULL; - } - - become_root(); - file->fd = open(file->path, O_RDWR|O_CREAT, 0644); - unbecome_root(); - - if (file->fd < 0) { - DEBUG(3, ("Could not open/create %s: %s\n", - file->path, strerror(errno))); - TALLOC_FREE(result); - return NULL; - } - - talloc_set_destructor(file, db_locked_file_destr); - - fl.l_type = F_WRLCK; - fl.l_whence = SEEK_SET; - fl.l_start = 0; - fl.l_len = 1; - fl.l_pid = 0; - - do { - ret = fcntl(file->fd, F_SETLKW, &fl); - } while ((ret == -1) && (errno == EINTR)); - - if (ret == -1) { - DEBUG(3, ("Could not get lock on %s: %s\n", - file->path, strerror(errno))); - TALLOC_FREE(result); - return NULL; - } - - if (sys_fstat(file->fd, &statbuf, false) != 0) { - DEBUG(3, ("Could not fstat %s: %s\n", - file->path, strerror(errno))); - TALLOC_FREE(result); - return NULL; - } - - if (statbuf.st_ex_nlink == 0) { - /* Someone has deleted it under the lock, retry */ - TALLOC_FREE(result); - goto again; - } - - result->value.dsize = 0; - result->value.dptr = NULL; - - if (statbuf.st_ex_size != 0) { - NTSTATUS status; - - result->value.dsize = statbuf.st_ex_size; - result->value.dptr = talloc_array(result, uint8_t, - statbuf.st_ex_size); - if (result->value.dptr == NULL) { - DEBUG(1, ("talloc failed\n")); - TALLOC_FREE(result); - return NULL; - } - - status = read_data(file->fd, (char *)result->value.dptr, - result->value.dsize); - if (!NT_STATUS_IS_OK(status)) { - DEBUG(3, ("read_data failed: %s\n", - nt_errstr(status))); - TALLOC_FREE(result); - return NULL; - } - } - - ctx->locked_record = result; - file->parent = (struct db_file_ctx *)talloc_reference(file, ctx); - - return result; -} - -static NTSTATUS db_file_store_root(int fd, TDB_DATA data) -{ - if (lseek(fd, 0, SEEK_SET) != 0) { - DEBUG(0, ("lseek failed: %s\n", strerror(errno))); - return map_nt_error_from_unix(errno); - } - - if (write_data(fd, (char *)data.dptr, data.dsize) != data.dsize) { - DEBUG(3, ("write_data failed: %s\n", strerror(errno))); - return map_nt_error_from_unix(errno); - } - - if (ftruncate(fd, data.dsize) != 0) { - DEBUG(3, ("ftruncate failed: %s\n", strerror(errno))); - return map_nt_error_from_unix(errno); - } - - return NT_STATUS_OK; -} - -static NTSTATUS db_file_store(struct db_record *rec, TDB_DATA data, int flag) -{ - struct db_locked_file *file = - talloc_get_type_abort(rec->private_data, - struct db_locked_file); - NTSTATUS status; - - become_root(); - status = db_file_store_root(file->fd, data); - unbecome_root(); - - return status; -} - -static NTSTATUS db_file_delete(struct db_record *rec) -{ - struct db_locked_file *file = - talloc_get_type_abort(rec->private_data, - struct db_locked_file); - int res; - - become_root(); - res = unlink(file->path); - unbecome_root(); - - if (res == -1) { - DEBUG(3, ("unlink(%s) failed: %s\n", file->path, - strerror(errno))); - return map_nt_error_from_unix(errno); - } - - return NT_STATUS_OK; -} - -static int db_file_traverse(struct db_context *db, - int (*fn)(struct db_record *rec, - void *private_data), - void *private_data) -{ - struct db_file_ctx *ctx = talloc_get_type_abort(db->private_data, - struct db_file_ctx); - TALLOC_CTX *mem_ctx = talloc_init("traversal %s\n", ctx->dirname); - - int i; - int count = 0; - - for (i=0; i<256; i++) { - const char *dirname = talloc_asprintf(mem_ctx, "%s/%2.2X", - ctx->dirname, i); - DIR *dir; - struct dirent *dirent; - - if (dirname == NULL) { - DEBUG(0, ("talloc failed\n")); - TALLOC_FREE(mem_ctx); - return -1; - } - - dir = opendir(dirname); - if (dir == NULL) { - DEBUG(3, ("Could not open dir %s: %s\n", dirname, - strerror(errno))); - TALLOC_FREE(mem_ctx); - return -1; - } - - while ((dirent = readdir(dir)) != NULL) { - DATA_BLOB keyblob; - TDB_DATA key; - struct db_record *rec; - - if ((dirent->d_name[0] == '.') && - ((dirent->d_name[1] == '\0') || - ((dirent->d_name[1] == '.') && - (dirent->d_name[2] == '\0')))) { - continue; - } - - keyblob = strhex_to_data_blob(mem_ctx, dirent->d_name); - if (keyblob.data == NULL) { - DEBUG(5, ("strhex_to_data_blob failed\n")); - continue; - } - - key.dptr = keyblob.data; - key.dsize = keyblob.length; - - if ((ctx->locked_record != NULL) && - (key.dsize == ctx->locked_record->key.dsize) && - (memcmp(key.dptr, ctx->locked_record->key.dptr, - key.dsize) == 0)) { - count += 1; - if (fn(ctx->locked_record, - private_data) != 0) { - TALLOC_FREE(mem_ctx); - closedir(dir); - return count; - } - } - - rec = db_file_fetch_locked(db, mem_ctx, key); - if (rec == NULL) { - /* Someone might have deleted it */ - continue; - } - - if (rec->value.dptr == NULL) { - TALLOC_FREE(rec); - continue; - } - - count += 1; - - if (fn(rec, private_data) != 0) { - TALLOC_FREE(mem_ctx); - closedir(dir); - return count; - } - TALLOC_FREE(rec); - } - - closedir(dir); - } - - TALLOC_FREE(mem_ctx); - return count; -} - -struct db_context *db_open_file(TALLOC_CTX *mem_ctx, - struct messaging_context *msg_ctx, - const char *name, - int hash_size, int tdb_flags, - int open_flags, mode_t mode) -{ - struct db_context *result = NULL; - struct db_file_ctx *ctx; - - if (!(result = talloc_zero(mem_ctx, struct db_context))) { - DEBUG(0, ("talloc failed\n")); - return NULL; - } - - if (!(ctx = talloc(result, struct db_file_ctx))) { - DEBUG(0, ("talloc failed\n")); - TALLOC_FREE(result); - return NULL; - } - - result->private_data = ctx; - result->fetch_locked = db_file_fetch_locked; - result->try_fetch_locked = NULL; - result->traverse = db_file_traverse; - result->traverse_read = db_file_traverse; - result->persistent = ((tdb_flags & TDB_CLEAR_IF_FIRST) == 0); - - ctx->locked_record = NULL; - if (!(ctx->dirname = talloc_strdup(ctx, name))) { - DEBUG(0, ("talloc failed\n")); - TALLOC_FREE(result); - return NULL; - } - - if (open_flags & O_CREAT) { - int ret, i; - - mode |= (mode & S_IRUSR) ? S_IXUSR : 0; - mode |= (mode & S_IRGRP) ? S_IXGRP : 0; - mode |= (mode & S_IROTH) ? S_IXOTH : 0; - - ret = mkdir(name, mode); - if ((ret != 0) && (errno != EEXIST)) { - DEBUG(5, ("mkdir(%s,%o) failed: %s\n", name, mode, - strerror(errno))); - TALLOC_FREE(result); - return NULL; - } - - for (i=0; i<256; i++) { - char *path; - path = talloc_asprintf(result, "%s/%2.2X", name, i); - if (path == NULL) { - DEBUG(0, ("asprintf failed\n")); - TALLOC_FREE(result); - return NULL; - } - ret = mkdir(path, mode); - if ((ret != 0) && (errno != EEXIST)) { - DEBUG(5, ("mkdir(%s,%o) failed: %s\n", path, - mode, strerror(errno))); - TALLOC_FREE(result); - return NULL; - } - TALLOC_FREE(path); - } - } - - return result; -} diff --git a/source3/lib/dbwrap/dbwrap_file.h b/source3/lib/dbwrap/dbwrap_file.h deleted file mode 100644 index 002f64dce5..0000000000 --- a/source3/lib/dbwrap/dbwrap_file.h +++ /dev/null @@ -1,36 +0,0 @@ -/* - Unix SMB/CIFS implementation. - Database interface using a file per record - Copyright (C) Volker Lendecke 2005 - - 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 . -*/ - -#ifndef __DBWRAP_FILE_H__ -#define __DBWRAP_FILE_H__ - -#include - -struct db_context; - -struct messaging_context; - -struct db_context *db_open_file(TALLOC_CTX *mem_ctx, - struct messaging_context *msg_ctx, - const char *name, - int hash_size, int tdb_flags, - int open_flags, mode_t mode); - - -#endif /* __DBWRAP_FILE_H__ */ diff --git a/source3/lib/dbwrap/dbwrap_private.h b/source3/lib/dbwrap/dbwrap_private.h deleted file mode 100644 index c197ffacf2..0000000000 --- a/source3/lib/dbwrap/dbwrap_private.h +++ /dev/null @@ -1,70 +0,0 @@ -/* - 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 . -*/ - -#ifndef __DBWRAP_PRIVATE_H__ -#define __DBWRAP_PRIVATE_H__ - -struct db_record { - struct db_context *db; - TDB_DATA key, value; - NTSTATUS (*store)(struct db_record *rec, TDB_DATA data, 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); - struct db_record *(*try_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 (*get_flags)(struct db_context *db); - int (*transaction_start)(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); - int (*exists)(struct db_context *db,TDB_DATA key); - int (*wipe)(struct db_context *db); - void (*id)(struct db_context *db, const uint8_t **id, size_t *idlen); - void *private_data; - enum dbwrap_lock_order lock_order; - bool persistent; - void (*stored_callback)(struct db_context *db, struct db_record *rec, - void *private_data); - void *stored_callback_private_data; -}; - -#endif /* __DBWRAP_PRIVATE_H__ */ - diff --git a/source3/lib/dbwrap/dbwrap_rbt.c b/source3/lib/dbwrap/dbwrap_rbt.c deleted file mode 100644 index c25ea6ec64..0000000000 --- a/source3/lib/dbwrap/dbwrap_rbt.c +++ /dev/null @@ -1,450 +0,0 @@ -/* - 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 . -*/ - -#include "includes.h" -#include "dbwrap/dbwrap.h" -#include "dbwrap/dbwrap_private.h" -#include "dbwrap/dbwrap_rbt.h" -#include "../lib/util/rbtree.h" - -#define DBWRAP_RBT_ALIGN(_size_) (((_size_)+15)&~15) - -struct db_rbt_ctx { - struct rb_root tree; -}; - -struct db_rbt_rec { - struct db_rbt_ctx *db_ctx; - 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; - - /* - * key and value are appended implicitly, "data" is only here as a - * target for offsetof() - */ - - char data[1]; -}; - -/* - * 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) -{ - key->dptr = ((uint8_t *)node) + offsetof(struct db_rbt_node, data); - key->dsize = node->keysize; - value->dptr = key->dptr + node->keysize; - value->dsize = node->valuesize; -} - -static NTSTATUS db_rbt_store(struct db_record *rec, TDB_DATA data, int flag) -{ - 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; - - TDB_DATA this_key, this_val; - - 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; - return NT_STATUS_OK; - } - - /* - * 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, &rec_priv->db_ctx->tree); - - /* - * Keep the existing node around for a while: If the record - * existed before, we reference the key data in there. - */ - } - - node = (struct db_rbt_node *)talloc_size(rec_priv->db_ctx, - offsetof(struct db_rbt_node, data) + rec->key.dsize - + data.dsize); - - if (node == NULL) { - TALLOC_FREE(rec_priv->node); - return NT_STATUS_NO_MEMORY; - } - - ZERO_STRUCT(node->rb_node); - - 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); - - memcpy(this_val.dptr, data.dptr, node->valuesize); - - parent = NULL; - p = &rec_priv->db_ctx->tree.rb_node; - - while (*p) { - struct db_rbt_node *r; - TDB_DATA search_key, search_val; - int res; - - parent = (*p); - - r = db_rbt2node(*p); - - 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); - rb_insert_color(&node->rb_node, &rec_priv->db_ctx->tree); - - return NT_STATUS_OK; -} - -static NTSTATUS db_rbt_delete(struct db_record *rec) -{ - struct db_rbt_rec *rec_priv = (struct db_rbt_rec *)rec->private_data; - - if (rec_priv->node == NULL) { - return NT_STATUS_OK; - } - - rb_erase(&rec_priv->node->rb_node, &rec_priv->db_ctx->tree); - 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, search_val; - - 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_ctx *ctx = talloc_get_type_abort( - db_ctx->private_data, struct db_rbt_ctx); - - 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))); - rec_priv->db_ctx = ctx; - - result->store = db_rbt_store; - result->delete_rec = db_rbt_delete; - result->private_data = rec_priv; - - rec_priv->node = res.node; - result->value = res.val; - - 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 rb_node *n, - int (*f)(struct db_record *db, - void *private_data), - void *private_data, uint32_t* count) -{ - struct db_rbt_node *r; - struct db_record rec; - int ret; - - if (n == NULL) { - return 0; - } - - ret = db_rbt_traverse_internal(n->rb_left, f, private_data, count); - if (ret != 0) { - return ret; - } - - r = db_rbt2node(n); - ZERO_STRUCT(rec); - db_rbt_parse_node(r, &rec.key, &rec.value); - - ret = f(&rec, private_data); - (*count) ++; - if (ret != 0) { - return ret; - } - - return db_rbt_traverse_internal(n->rb_right, f, private_data, 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 = db_rbt_traverse_internal(ctx->tree.rb_node, f, private_data, &count); - 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 void db_rbt_id(struct db_context *db, const uint8_t **id, size_t *idlen) -{ - *id = (uint8_t *)db; - *idlen = sizeof(db); -} - -struct db_context *db_open_rbt(TALLOC_CTX *mem_ctx) -{ - struct db_context *result; - - result = talloc(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->try_fetch_locked = NULL; - result->traverse = db_rbt_traverse; - result->traverse_read = db_rbt_traverse; - 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->lock_order = 0; - result->id = db_rbt_id; - result->stored_callback = NULL; - - return result; -} diff --git a/source3/lib/dbwrap/dbwrap_rbt.h b/source3/lib/dbwrap/dbwrap_rbt.h deleted file mode 100644 index 1716879de6..0000000000 --- a/source3/lib/dbwrap/dbwrap_rbt.h +++ /dev/null @@ -1,29 +0,0 @@ -/* - 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 . -*/ - -#ifndef __DBWRAP_RBT_H__ -#define __DBWRAP_RBT_H__ - -#include - -struct db_context; - -struct db_context *db_open_rbt(TALLOC_CTX *mem_ctx); - -#endif /* __DBWRAP_RBT_H__ */ diff --git a/source3/lib/dbwrap/dbwrap_tdb.c b/source3/lib/dbwrap/dbwrap_tdb.c deleted file mode 100644 index 798d391b1f..0000000000 --- a/source3/lib/dbwrap/dbwrap_tdb.c +++ /dev/null @@ -1,447 +0,0 @@ -/* - 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 . -*/ - -#include "includes.h" -#include "dbwrap/dbwrap.h" -#include "dbwrap/dbwrap_private.h" -#include "dbwrap/dbwrap_tdb.h" -#include "lib/tdb_wrap/tdb_wrap.h" -#include "util_tdb.h" -#include "system/filesys.h" - -struct db_tdb_ctx { - struct tdb_wrap *wtdb; - - struct { - dev_t dev; - ino_t ino; - } id; -}; - -static NTSTATUS db_tdb_store(struct db_record *rec, TDB_DATA data, int flag); -static NTSTATUS db_tdb_delete(struct db_record *rec); - -static void db_tdb_log_key(const char *prefix, TDB_DATA key) -{ - size_t len; - char *keystr; - - if (DEBUGLEVEL < 10) { - return; - } - len = key.dsize; - if (DEBUGLEVEL == 10) { - /* - * Only fully spam at debuglevel > 10 - */ - len = MIN(10, key.dsize); - } - keystr = hex_encode_talloc(talloc_tos(), (unsigned char *)(key.dptr), - len); - DEBUG(10, ("%s key %s\n", prefix, keystr)); - TALLOC_FREE(keystr); -} - -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; - } - - return 0; -} - -static struct db_record *db_tdb_fetch_locked_internal( - 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); - struct tdb_fetch_locked_state state; - - state.mem_ctx = mem_ctx; - state.result = NULL; - - if ((tdb_parse_record(ctx->wtdb->tdb, key, db_tdb_fetchlock_parse, - &state) < 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 = talloc_reference(state.result, ctx); - state.result->store = db_tdb_store; - state.result->delete_rec = db_tdb_delete; - - DEBUG(10, ("Allocated locked data 0x%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, mem_ctx, key); -} - -static struct db_record *db_tdb_try_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("Trying to lock", key); - if (tdb_chainlock_nonblock(ctx->wtdb->tdb, key) != 0) { - DEBUG(3, ("tdb_chainlock_nonblock failed\n")); - return NULL; - } - return db_tdb_fetch_locked_internal(db, mem_ctx, key); -} - - -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); -} - -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_store(struct db_record *rec, TDB_DATA data, int flag) -{ - struct db_tdb_ctx *ctx = talloc_get_type_abort(rec->private_data, - struct db_tdb_ctx); - - /* - * 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. - */ - - return (tdb_store(ctx->wtdb->tdb, rec->key, data, flag) == 0) ? - NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL; -} - -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.store = db_tdb_store; - 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_store_deny(struct db_record *rec, TDB_DATA data, 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.store = db_tdb_store_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_get_flags(struct db_context *db) - -{ - struct db_tdb_ctx *db_ctx = - talloc_get_type_abort(db->private_data, struct db_tdb_ctx); - return tdb_get_flags(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 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 void db_tdb_id(struct db_context *db, const uint8_t **id, size_t *idlen) -{ - struct db_tdb_ctx *db_ctx = - talloc_get_type_abort(db->private_data, struct db_tdb_ctx); - *id = (uint8_t *)&db_ctx->id; - *idlen = sizeof(db_ctx->id); -} - -struct db_context *db_open_tdb(TALLOC_CTX *mem_ctx, - struct loadparm_context *lp_ctx, - const char *name, - int hash_size, int tdb_flags, - int open_flags, mode_t mode, - enum dbwrap_lock_order lock_order) -{ - 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, lp_ctx); - 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->try_fetch_locked = db_tdb_try_fetch_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->get_flags = db_tdb_get_flags; - result->persistent = ((tdb_flags & TDB_CLEAR_IF_FIRST) == 0); - result->transaction_start = db_tdb_transaction_start; - 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->stored_callback = NULL; - return result; - - fail: - if (result != NULL) { - TALLOC_FREE(result); - } - return NULL; -} diff --git a/source3/lib/dbwrap/dbwrap_tdb.h b/source3/lib/dbwrap/dbwrap_tdb.h deleted file mode 100644 index 6a6da45a08..0000000000 --- a/source3/lib/dbwrap/dbwrap_tdb.h +++ /dev/null @@ -1,35 +0,0 @@ -/* - 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 . -*/ - -#ifndef __DBWRAP_TDB_H__ -#define __DBWRAP_TDB_H__ - -#include - -struct db_context; - -struct db_context *db_open_tdb(TALLOC_CTX *mem_ctx, - struct loadparm_context *lp_ctx, - const char *name, - int hash_size, int tdb_flags, - int open_flags, mode_t mode, - enum dbwrap_lock_order lock_order); - - -#endif /* __DBWRAP_TDB_H__ */ diff --git a/source3/lib/dbwrap/dbwrap_util.c b/source3/lib/dbwrap/dbwrap_util.c deleted file mode 100644 index f5771c2398..0000000000 --- a/source3/lib/dbwrap/dbwrap_util.c +++ /dev/null @@ -1,539 +0,0 @@ -/* - Unix SMB/CIFS implementation. - Utility functions for the dbwrap API - Copyright (C) Volker Lendecke 2007 - Copyright (C) Michael Adam 2009 - Copyright (C) Jim McDonough 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 "util_tdb.h" - -NTSTATUS dbwrap_fetch_int32(struct db_context *db, const char *keystr, - int32_t *result) -{ - TDB_DATA dbuf; - NTSTATUS status; - - if (result == NULL) { - return NT_STATUS_INVALID_PARAMETER; - } - - status = dbwrap_fetch_bystring(db, NULL, keystr, &dbuf); - if (!NT_STATUS_IS_OK(status)) { - return status; - } - - if ((dbuf.dptr == NULL) || (dbuf.dsize != sizeof(int32_t))) { - TALLOC_FREE(dbuf.dptr); - return NT_STATUS_NOT_FOUND; - } - - *result = IVAL(dbuf.dptr, 0); - TALLOC_FREE(dbuf.dptr); - return NT_STATUS_OK; -} - -NTSTATUS dbwrap_store_int32(struct db_context *db, const char *keystr, - int32_t v) -{ - struct db_record *rec; - int32_t v_store; - NTSTATUS status; - - rec = dbwrap_fetch_locked(db, NULL, string_term_tdb_data(keystr)); - if (rec == NULL) { - return NT_STATUS_UNSUCCESSFUL; - } - - SIVAL(&v_store, 0, v); - - status = dbwrap_record_store(rec, - make_tdb_data((const uint8_t *)&v_store, - sizeof(v_store)), - TDB_REPLACE); - TALLOC_FREE(rec); - return status; -} - -NTSTATUS dbwrap_fetch_uint32(struct db_context *db, const char *keystr, - uint32_t *val) -{ - TDB_DATA dbuf; - NTSTATUS status; - - if (val == NULL) { - return NT_STATUS_INVALID_PARAMETER; - } - - status = dbwrap_fetch_bystring(db, NULL, keystr, &dbuf); - if (!NT_STATUS_IS_OK(status)) { - return status; - } - - if ((dbuf.dptr == NULL) || (dbuf.dsize != sizeof(uint32_t))) { - TALLOC_FREE(dbuf.dptr); - return NT_STATUS_NOT_FOUND; - } - - *val = IVAL(dbuf.dptr, 0); - TALLOC_FREE(dbuf.dptr); - return NT_STATUS_OK; -} - -NTSTATUS dbwrap_store_uint32(struct db_context *db, const char *keystr, - uint32_t v) -{ - struct db_record *rec; - uint32_t v_store; - NTSTATUS status; - - rec = dbwrap_fetch_locked(db, NULL, string_term_tdb_data(keystr)); - if (rec == NULL) { - return NT_STATUS_INVALID_PARAMETER; - } - - SIVAL(&v_store, 0, v); - - status = dbwrap_record_store(rec, - make_tdb_data((const uint8_t *)&v_store, - sizeof(v_store)), - TDB_REPLACE); - TALLOC_FREE(rec); - 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, NULL, 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(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(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 { - const char *keystr; - 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, NULL, 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_int32_atomic(struct db_context *db, const char *keystr, - int32_t *oldval, int32_t change_val) -{ - NTSTATUS ret; - struct dbwrap_change_int32_atomic_context state; - - state.keystr = keystr; - state.oldval = oldval; - state.change_val = change_val; - - ret = dbwrap_change_int32_atomic_action(db, &state); - - return ret; -} - -NTSTATUS dbwrap_trans_change_int32_atomic(struct db_context *db, - const char *keystr, - int32_t *oldval, - int32_t change_val) -{ - NTSTATUS ret; - struct dbwrap_change_int32_atomic_context state; - - state.keystr = 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) -{ - struct db_record *rec = NULL; - NTSTATUS status; - struct dbwrap_store_context *store_ctx; - - store_ctx = (struct dbwrap_store_context *)private_data; - - rec = dbwrap_fetch_locked(db, talloc_tos(), *(store_ctx->key)); - if (rec == NULL) { - DEBUG(5, ("fetch_locked failed\n")); - return NT_STATUS_NO_MEMORY; - } - - status = dbwrap_record_store(rec, *(store_ctx->dbuf), store_ctx->flag); - if (!NT_STATUS_IS_OK(status)) { - DEBUG(5, ("store returned %s\n", nt_errstr(status))); - } - - TALLOC_FREE(rec); - 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; - struct db_record *rec; - TDB_DATA *key = (TDB_DATA *)private_data; - - rec = dbwrap_fetch_locked(db, talloc_tos(), *key); - if (rec == NULL) { - DEBUG(5, ("fetch_locked failed\n")); - return NT_STATUS_NO_MEMORY; - } - - status = dbwrap_record_delete(rec); - if (!NT_STATUS_IS_OK(status)) { - DEBUG(5, ("delete_rec returned %s\n", nt_errstr(status))); - } - - talloc_free(rec); - 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(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(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_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; -} diff --git a/source3/lib/dbwrap/dbwrap_watch.c b/source3/lib/dbwrap/dbwrap_watch.c index 59288057f0..ea75427ffc 100644 --- a/source3/lib/dbwrap/dbwrap_watch.c +++ b/source3/lib/dbwrap/dbwrap_watch.c @@ -19,7 +19,7 @@ #include "includes.h" #include "system/filesys.h" -#include "dbwrap.h" +#include "dbwrap/dbwrap.h" #include "dbwrap_watch.h" #include "dbwrap_open.h" #include "msg_channel.h" diff --git a/source3/lib/dbwrap/dbwrap_watch.h b/source3/lib/dbwrap/dbwrap_watch.h index e242fa188a..66fef32698 100644 --- a/source3/lib/dbwrap/dbwrap_watch.h +++ b/source3/lib/dbwrap/dbwrap_watch.h @@ -21,7 +21,7 @@ #define __DBWRAP_WATCH_H__ #include -#include "dbwrap.h" +#include "dbwrap/dbwrap.h" #include "messages.h" void dbwrap_watch_db(struct db_context *db, struct messaging_context *msg); diff --git a/source3/wscript_build b/source3/wscript_build index ad19c3390f..adc9892519 100755 --- a/source3/wscript_build +++ b/source3/wscript_build @@ -1063,11 +1063,6 @@ bld.SAMBA3_SUBSYSTEM('tdb-wrap3', deps='talloc samba3-util', vars=locals()) -bld.SAMBA3_LIBRARY('dbwrap', - source='lib/dbwrap/dbwrap.c lib/dbwrap/dbwrap_util.c lib/dbwrap/dbwrap_rbt.c lib/dbwrap/dbwrap_cache.c lib/dbwrap/dbwrap_tdb.c', - deps='samba-util util_tdb errors tdb tdb-wrap', - private_library=True) - bld.SAMBA3_LIBRARY('samba3-util', source='''lib/util_sec.c lib/util_str.c lib/adt_tree.c lib/util_malloc.c lib/memcache.c lib/string_init.c lib/namearray.c lib/file_id.c''', deps='samba-util charset', diff --git a/source4/ntvfs/posix/python/pyxattr_tdb.c b/source4/ntvfs/posix/python/pyxattr_tdb.c index 18ac091787..1df9897e9a 100644 --- a/source4/ntvfs/posix/python/pyxattr_tdb.c +++ b/source4/ntvfs/posix/python/pyxattr_tdb.c @@ -28,9 +28,9 @@ #include "ntvfs/posix/posix_eadb.h" #include "libcli/util/pyerrors.h" #include "param/pyparam.h" -#include "source3/lib/dbwrap/dbwrap.h" -#include "source3/lib/dbwrap/dbwrap_open.h" -#include "source3/lib/dbwrap/dbwrap_tdb.h" +#include "lib/dbwrap/dbwrap.h" +#include "lib/dbwrap/dbwrap_open.h" +#include "lib/dbwrap/dbwrap_tdb.h" #include "source3/lib/xattr_tdb.h" void initxattr_tdb(void); diff --git a/wscript_build b/wscript_build index 0a9d6976ed..ddec5798a5 100755 --- a/wscript_build +++ b/wscript_build @@ -96,6 +96,7 @@ bld.RECURSE('libcli/cldap') bld.RECURSE('lib/subunit/c') bld.RECURSE('lib/smbconf') bld.RECURSE('lib/async_req') +bld.RECURSE('lib/dbwrap') bld.RECURSE('libcli/security') bld.RECURSE('libcli/ldap') bld.RECURSE('libcli/nbt') -- cgit