-/*
+/*
ldb database library
- Copyright (C) Andrew Tridgell 2004
- Copyright (C) Stefan Metzmacher 2004
- Copyright (C) Simo Sorce 2006
-
+ Copyright (C) Andrew Tridgell 2004
+ Copyright (C) Stefan Metzmacher 2004
+ Copyright (C) Simo Sorce 2006-2008
+ Copyright (C) Matthias Dieter Wallnöfer 2009
** NOTE! The following LGPL license applies to the ldb
** library. This does NOT imply that all of Samba is released
** under the LGPL
-
+
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
- version 2 of the License, or (at your option) any later version.
+ version 3 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ License along with this library; if not, see <http://www.gnu.org/licenses/>.
*/
/*
* - description: make the module use asyncronous calls
* date: Feb 2006
* Author: Simo Sorce
+ *
+ * - description: make it possible to use event contexts
+ * date: Jan 2008
+ * Author: Simo Sorce
+ *
+ * - description: fix up memory leaks and small bugs
+ * date: Oct 2009
+ * Author: Matthias Dieter Wallnöfer
*/
-#include "includes.h"
-#include "ldb/include/includes.h"
-
-#include "ldb/ldb_tdb/ldb_tdb.h"
+#include "ldb_tdb.h"
/*
return LDB_ERR_OTHER;
}
-
-struct ldb_async_handle *init_ltdb_handle(struct ltdb_private *ltdb, struct ldb_module *module,
- void *context,
- int (*callback)(struct ldb_context *, void *, struct ldb_async_result *))
+/*
+ lock the database for read - use by ltdb_search and ltdb_sequence_number
+*/
+int ltdb_lock_read(struct ldb_module *module)
{
- struct ltdb_async_context *ac;
- struct ldb_async_handle *h;
-
- h = talloc_zero(ltdb, struct ldb_async_handle);
- if (h == NULL) {
- ldb_set_errstring(module->ldb, talloc_asprintf(module, "Out of Memory"));
- return NULL;
+ void *data = ldb_module_get_private(module);
+ struct ltdb_private *ltdb = talloc_get_type(data, struct ltdb_private);
+ if (ltdb->in_transaction == 0) {
+ return tdb_lockall_read(ltdb->tdb);
}
+ return 0;
+}
- h->module = module;
-
- ac = talloc_zero(h, struct ltdb_async_context);
- if (ac == NULL) {
- ldb_set_errstring(module->ldb, talloc_asprintf(module, "Out of Memory"));
- talloc_free(h);
- return NULL;
+/*
+ unlock the database after a ltdb_lock_read()
+*/
+int ltdb_unlock_read(struct ldb_module *module)
+{
+ void *data = ldb_module_get_private(module);
+ struct ltdb_private *ltdb = talloc_get_type(data, struct ltdb_private);
+ if (ltdb->in_transaction == 0) {
+ return tdb_unlockall_read(ltdb->tdb);
}
-
- h->private_data = (void *)ac;
-
- h->state = LDB_ASYNC_INIT;
- h->status = LDB_SUCCESS;
-
- ac->module = module;
- ac->context = context;
- ac->callback = callback;
-
- return h;
+ return 0;
}
+
/*
form a TDB_DATA for a record key
caller frees
- note that the key for a record can depend on whether the
+ note that the key for a record can depend on whether the
dn refers to a case sensitive index record or not
*/
-struct TDB_DATA ltdb_key(struct ldb_module *module, const struct ldb_dn *dn)
+struct TDB_DATA ltdb_key(struct ldb_module *module, struct ldb_dn *dn)
{
- struct ldb_context *ldb = module->ldb;
+ struct ldb_context *ldb = ldb_module_get_ctx(module);
TDB_DATA key;
char *key_str = NULL;
- char *dn_folded = NULL;
+ const char *dn_folded = NULL;
/*
most DNs are case insensitive. The exception is index DNs for
1) if the dn doesn't start with @ then uppercase the attribute
names and the attributes values of case insensitive attributes
- 2) if the dn starts with @ then leave it alone - the indexing code handles
- the rest
+ 2) if the dn starts with @ then leave it alone -
+ the indexing code handles the rest
*/
- dn_folded = ldb_dn_linearize_casefold(ldb, dn);
+ dn_folded = ldb_dn_get_casefold(dn);
if (!dn_folded) {
goto failed;
}
- key_str = talloc_asprintf(ldb, "DN=%s", dn_folded);
-
- talloc_free(dn_folded);
+ key_str = talloc_strdup(ldb, "DN=");
+ if (!key_str) {
+ goto failed;
+ }
+ key_str = talloc_strdup_append_buffer(key_str, dn_folded);
if (!key_str) {
goto failed;
}
check special dn's have valid attributes
currently only @ATTRIBUTES is checked
*/
-int ltdb_check_special_dn(struct ldb_module *module, const struct ldb_message *msg)
+static int ltdb_check_special_dn(struct ldb_module *module,
+ const struct ldb_message *msg)
{
+ struct ldb_context *ldb = ldb_module_get_ctx(module);
int i, j;
-
+
if (! ldb_dn_is_special(msg->dn) ||
! ldb_dn_check_special(msg->dn, LTDB_ATTRIBUTES)) {
- return 0;
+ return LDB_SUCCESS;
}
/* we have @ATTRIBUTES, let's check attributes are fine */
for (i = 0; i < msg->num_elements; i++) {
for (j = 0; j < msg->elements[i].num_values; j++) {
if (ltdb_check_at_attributes_values(&msg->elements[i].values[j]) != 0) {
- char *err_string = talloc_strdup(module, "Invalid attribute value in an @ATTRIBUTES entry");
- if (err_string) {
- ldb_set_errstring(module->ldb, err_string);
- }
+ ldb_set_errstring(ldb, "Invalid attribute value in an @ATTRIBUTES entry");
return LDB_ERR_INVALID_ATTRIBUTE_SYNTAX;
}
}
}
- return 0;
+ return LDB_SUCCESS;
}
/*
- we've made a modification to a dn - possibly reindex and
+ we've made a modification to a dn - possibly reindex and
update sequence number
*/
-static int ltdb_modified(struct ldb_module *module, const struct ldb_dn *dn)
+static int ltdb_modified(struct ldb_module *module, struct ldb_dn *dn)
{
- int ret = 0;
+ int ret = LDB_SUCCESS;
if (ldb_dn_is_special(dn) &&
(ldb_dn_check_special(dn, LTDB_INDEXLIST) ||
ret = ltdb_reindex(module);
}
- if (ret == 0 &&
+ /* If the modify was to a normal record, or any special except @BASEINFO, update the seq number */
+ if (ret == LDB_SUCCESS &&
!(ldb_dn_is_special(dn) &&
ldb_dn_check_special(dn, LTDB_BASEINFO)) ) {
ret = ltdb_increase_sequence_number(module);
}
+ /* If the modify was to @OPTIONS, reload the cache */
+ if (ldb_dn_is_special(dn) &&
+ (ldb_dn_check_special(dn, LTDB_OPTIONS)) ) {
+ ret = ltdb_cache_reload(module);
+ }
+
return ret;
}
*/
int ltdb_store(struct ldb_module *module, const struct ldb_message *msg, int flgs)
{
- struct ltdb_private *ltdb = module->private_data;
+ void *data = ldb_module_get_private(module);
+ struct ltdb_private *ltdb = talloc_get_type(data, struct ltdb_private);
TDB_DATA tdb_key, tdb_data;
- int ret;
+ int ret = LDB_SUCCESS;
tdb_key = ltdb_key(module, msg->dn);
if (!tdb_key.dptr) {
ret = ltdb_err_map(tdb_error(ltdb->tdb));
goto done;
}
-
+
ret = ltdb_index_add(module, msg);
- if (ret == -1) {
+ if (ret != LDB_SUCCESS) {
tdb_delete(ltdb->tdb, tdb_key);
}
}
-/*
- add a record to the database
-*/
-static int ltdb_add_async(struct ldb_module *module, const struct ldb_message *msg,
- void *context,
- int (*callback)(struct ldb_context *, void *, struct ldb_async_result *),
- struct ldb_async_handle **handle)
+static int ltdb_add_internal(struct ldb_module *module,
+ const struct ldb_message *msg)
{
- struct ltdb_private *ltdb = talloc_get_type(module->private_data, struct ltdb_private);
- struct ltdb_async_context *ltdb_ac;
- int tret, ret = LDB_SUCCESS;
+ struct ldb_context *ldb = ldb_module_get_ctx(module);
+ int ret = LDB_SUCCESS, i;
- *handle = init_ltdb_handle(ltdb, module, context, callback);
- if (*handle == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
- }
- ltdb_ac = talloc_get_type((*handle)->private_data, struct ltdb_async_context);
-
- tret = ltdb_check_special_dn(module, msg);
- if (tret != LDB_SUCCESS) {
- (*handle)->status = tret;
+ ret = ltdb_check_special_dn(module, msg);
+ if (ret != LDB_SUCCESS) {
goto done;
}
-
+
if (ltdb_cache_load(module) != 0) {
- ret = LDB_ERR_OTHER;
+ ret = LDB_ERR_OPERATIONS_ERROR;
goto done;
}
- tret = ltdb_store(module, msg, TDB_INSERT);
+ for (i=0;i<msg->num_elements;i++) {
+ struct ldb_message_element *el = &msg->elements[i];
+ const struct ldb_schema_attribute *a = ldb_schema_attribute_by_name(ldb, el->name);
+
+ if (el->num_values == 0) {
+ ldb_asprintf_errstring(ldb, "attribute %s on %s specified, but with 0 values (illegal)",
+ el->name, ldb_dn_get_linearized(msg->dn));
+ ret = LDB_ERR_CONSTRAINT_VIOLATION;
+ goto done;
+ }
+ if (a && a->flags & LDB_ATTR_FLAG_SINGLE_VALUE) {
+ if (el->num_values > 1) {
+ ldb_asprintf_errstring(ldb, "SINGLE-VALUE attribute %s on %s specified more than once",
+ el->name, ldb_dn_get_linearized(msg->dn));
+ ret = LDB_ERR_CONSTRAINT_VIOLATION;
+ goto done;
+ }
+ }
+ }
- if (tret != LDB_SUCCESS) {
- (*handle)->status = tret;
+ ret = ltdb_store(module, msg, TDB_INSERT);
+ if (ret != LDB_SUCCESS) {
+ if (ret == LDB_ERR_ENTRY_ALREADY_EXISTS) {
+ ldb_asprintf_errstring(ldb,
+ "Entry %s already exists",
+ ldb_dn_get_linearized(msg->dn));
+ }
goto done;
}
- ltdb_modified(module, msg->dn);
+ ret = ltdb_index_one(module, msg, 1);
+ if (ret != LDB_SUCCESS) {
+ goto done;
+ }
- if (ltdb_ac->callback) {
- ret = ltdb_ac->callback(module->ldb, ltdb_ac->context, NULL);
+ ret = ltdb_modified(module, msg->dn);
+ if (ret != LDB_SUCCESS) {
+ goto done;
}
done:
- (*handle)->state = LDB_ASYNC_DONE;
return ret;
}
-static int ltdb_add(struct ldb_module *module, const struct ldb_message *msg)
+/*
+ add a record to the database
+*/
+static int ltdb_add(struct ltdb_context *ctx)
{
- struct ldb_async_handle *handle;
- int ret;
+ struct ldb_module *module = ctx->module;
+ struct ldb_request *req = ctx->req;
+ int ret = LDB_SUCCESS;
- ret = ltdb_add_async(module, msg, NULL, NULL, &handle);
+ ldb_request_set_state(req, LDB_ASYNC_PENDING);
- if (ret != LDB_SUCCESS)
- return ret;
+ if (ltdb_cache_load(module) != 0) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
- ret = ldb_async_wait(handle, LDB_WAIT_ALL);
+ ret = ltdb_add_internal(module, req->op.add.message);
- talloc_free(handle);
return ret;
}
delete a record from the database, not updating indexes (used for deleting
index records)
*/
-int ltdb_delete_noindex(struct ldb_module *module, const struct ldb_dn *dn)
+int ltdb_delete_noindex(struct ldb_module *module, struct ldb_dn *dn)
{
- struct ltdb_private *ltdb = module->private_data;
+ void *data = ldb_module_get_private(module);
+ struct ltdb_private *ltdb = talloc_get_type(data, struct ltdb_private);
TDB_DATA tdb_key;
int ret;
return ret;
}
-/*
- delete a record from the database
-*/
-static int ltdb_delete_async(struct ldb_module *module, const struct ldb_dn *dn,
- void *context,
- int (*callback)(struct ldb_context *, void *, struct ldb_async_result *),
- struct ldb_async_handle **handle)
+static int ltdb_delete_internal(struct ldb_module *module, struct ldb_dn *dn)
{
- struct ltdb_private *ltdb = talloc_get_type(module->private_data, struct ltdb_private);
- struct ltdb_async_context *ltdb_ac;
struct ldb_message *msg;
- int tret, ret = LDB_SUCCESS;
-
- *handle = NULL;
+ int ret = LDB_SUCCESS;
- if (ltdb_cache_load(module) != 0) {
- return LDB_ERR_OPERATIONS_ERROR;
- }
-
- *handle = init_ltdb_handle(ltdb, module, context, callback);
- if (*handle == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
- }
- ltdb_ac = talloc_get_type((*handle)->private_data, struct ltdb_async_context);
-
- msg = talloc(ltdb_ac, struct ldb_message);
+ msg = talloc(module, struct ldb_message);
if (msg == NULL) {
- ret = LDB_ERR_OPERATIONS_ERROR;
- goto done;
+ return LDB_ERR_OPERATIONS_ERROR;
}
/* in case any attribute of the message was indexed, we need
to fetch the old record */
- tret = ltdb_search_dn1(module, dn, msg);
- if (tret != 1) {
+ ret = ltdb_search_dn1(module, dn, msg);
+ if (ret != LDB_SUCCESS) {
/* not finding the old record is an error */
- (*handle)->status = LDB_ERR_NO_SUCH_OBJECT;
goto done;
}
- tret = ltdb_delete_noindex(module, dn);
- if (tret != LDB_SUCCESS) {
- (*handle)->status = LDB_ERR_NO_SUCH_OBJECT;
+ ret = ltdb_delete_noindex(module, dn);
+ if (ret != LDB_SUCCESS) {
+ goto done;
+ }
+
+ /* remove one level attribute */
+ ret = ltdb_index_one(module, msg, 0);
+ if (ret != LDB_SUCCESS) {
goto done;
}
/* remove any indexed attributes */
- tret = ltdb_index_del(module, msg);
- if (tret != LDB_SUCCESS) {
- (*handle)->status = LDB_ERR_NO_SUCH_OBJECT;
+ ret = ltdb_index_del(module, msg);
+ if (ret != LDB_SUCCESS) {
goto done;
}
- ltdb_modified(module, dn);
- if (ltdb_ac->callback)
- ret = ltdb_ac->callback(module->ldb, ltdb_ac->context, NULL);
+ ret = ltdb_modified(module, dn);
+ if (ret != LDB_SUCCESS) {
+ goto done;
+ }
done:
- (*handle)->state = LDB_ASYNC_DONE;
+ talloc_free(msg);
return ret;
}
-static int ltdb_delete(struct ldb_module *module, const struct ldb_dn *dn)
+/*
+ delete a record from the database
+*/
+static int ltdb_delete(struct ltdb_context *ctx)
{
- struct ldb_async_handle *handle;
- int ret;
+ struct ldb_module *module = ctx->module;
+ struct ldb_request *req = ctx->req;
+ int ret = LDB_SUCCESS;
- ret = ltdb_delete_async(module, dn, NULL, NULL, &handle);
+ ldb_request_set_state(req, LDB_ASYNC_PENDING);
- if (ret != LDB_SUCCESS)
- return ret;
+ if (ltdb_cache_load(module) != 0) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
- ret = ldb_async_wait(handle, LDB_WAIT_ALL);
+ ret = ltdb_delete_internal(module, req->op.del.dn);
- talloc_free(handle);
return ret;
}
-
/*
- find an element by attribute name. At the moment this does a linear search, it should
- be re-coded to use a binary search once all places that modify records guarantee
- sorted order
+ find an element by attribute name. At the moment this does a linear search,
+ it should be re-coded to use a binary search once all places that modify
+ records guarantee sorted order
return the index of the first matching element if found, otherwise -1
*/
/*
add an element to an existing record. Assumes a elements array that we
- can call re-alloc on, and assumed that we can re-use the data pointers from the
- passed in additional values. Use with care!
+ can call re-alloc on, and assumed that we can re-use the data pointers from
+ the passed in additional values. Use with care!
returns 0 on success, -1 on failure (and sets errno)
*/
static int msg_add_element(struct ldb_context *ldb,
- struct ldb_message *msg, struct ldb_message_element *el)
+ struct ldb_message *msg,
+ struct ldb_message_element *el)
{
struct ldb_message_element *e2;
unsigned int i;
- e2 = talloc_realloc(msg, msg->elements, struct ldb_message_element,
+ if (el->num_values == 0) {
+ /* nothing to do here - we don't add empty elements */
+ return 0;
+ }
+
+ e2 = talloc_realloc(msg, msg->elements, struct ldb_message_element,
msg->num_elements+1);
if (!e2) {
errno = ENOMEM;
e2->name = el->name;
e2->flags = el->flags;
- e2->values = NULL;
- if (el->num_values != 0) {
- e2->values = talloc_array(msg->elements, struct ldb_val, el->num_values);
- if (!e2->values) {
- errno = ENOMEM;
- return -1;
- }
+ e2->values = talloc_array(msg->elements,
+ struct ldb_val, el->num_values);
+ if (!e2->values) {
+ errno = ENOMEM;
+ return -1;
}
for (i=0;i<el->num_values;i++) {
e2->values[i] = el->values[i];
}
e2->num_values = el->num_values;
- msg->num_elements++;
+ ++msg->num_elements;
return 0;
}
struct ldb_context *ldb,
struct ldb_message *msg, const char *name)
{
- char *dn;
+ const char *dn;
unsigned int i, j;
- dn = ldb_dn_linearize(ldb, msg->dn);
+ dn = ldb_dn_get_linearized(msg->dn);
if (dn == NULL) {
return -1;
}
for (i=0;i<msg->num_elements;i++) {
if (ldb_attr_cmp(msg->elements[i].name, name) == 0) {
for (j=0;j<msg->elements[i].num_values;j++) {
- ltdb_index_del_value(module, dn, &msg->elements[i], j);
+ ltdb_index_del_value(module, dn,
+ &msg->elements[i], j);
}
talloc_free(msg->elements[i].values);
if (msg->num_elements > (i+1)) {
- memmove(&msg->elements[i],
- &msg->elements[i+1],
+ memmove(&msg->elements[i],
+ &msg->elements[i+1],
sizeof(struct ldb_message_element)*
(msg->num_elements - (i+1)));
}
msg->num_elements--;
i--;
- msg->elements = talloc_realloc(msg, msg->elements,
- struct ldb_message_element,
- msg->num_elements);
+ msg->elements = talloc_realloc(msg, msg->elements,
+ struct ldb_message_element,
+ msg->num_elements);
+
+ /* per definition we find in a canonicalised message an
+ attribute only once. So we are finished here. */
+ return 0;
}
}
- talloc_free(dn);
- return 0;
+ /* Not found */
+ return -1;
}
/*
- delete all elements matching an attribute name/value
+ delete all elements matching an attribute name/value
return 0 on success, -1 on failure
*/
static int msg_delete_element(struct ldb_module *module,
- struct ldb_message *msg,
+ struct ldb_message *msg,
const char *name,
const struct ldb_val *val)
{
- struct ldb_context *ldb = module->ldb;
+ struct ldb_context *ldb = ldb_module_get_ctx(module);
unsigned int i;
int found;
struct ldb_message_element *el;
- const struct ldb_attrib_handler *h;
+ const struct ldb_schema_attribute *a;
found = find_element(msg, name);
if (found == -1) {
el = &msg->elements[found];
- h = ldb_attrib_handler(ldb, el->name);
+ a = ldb_schema_attribute_by_name(ldb, el->name);
for (i=0;i<el->num_values;i++) {
- if (h->comparison_fn(ldb, ldb, &el->values[i], val) == 0) {
+ if (a->syntax->comparison_fn(ldb, ldb,
+ &el->values[i], val) == 0) {
if (i<el->num_values-1) {
memmove(&el->values[i], &el->values[i+1],
- sizeof(el->values[i])*(el->num_values-(i+1)));
+ sizeof(el->values[i])*
+ (el->num_values-(i+1)));
}
el->num_values--;
if (el->num_values == 0) {
- return msg_delete_attribute(module, ldb, msg, name);
+ return msg_delete_attribute(module, ldb,
+ msg, name);
}
+
+ /* per definition we find in a canonicalised message an
+ attribute value only once. So we are finished here */
return 0;
}
}
+ /* Not found */
return -1;
}
modify a record - internal interface
yuck - this is O(n^2). Luckily n is usually small so we probably
- get away with it, but if we ever have really large attribute lists
+ get away with it, but if we ever have really large attribute lists
then we'll need to look at this again
*/
-int ltdb_modify_internal(struct ldb_module *module, const struct ldb_message *msg)
+int ltdb_modify_internal(struct ldb_module *module,
+ const struct ldb_message *msg)
{
- struct ldb_context *ldb = module->ldb;
- struct ltdb_private *ltdb = module->private_data;
+ struct ldb_context *ldb = ldb_module_get_ctx(module);
+ void *data = ldb_module_get_private(module);
+ struct ltdb_private *ltdb = talloc_get_type(data, struct ltdb_private);
TDB_DATA tdb_key, tdb_data;
struct ldb_message *msg2;
unsigned i, j;
- int ret;
+ int ret = LDB_SUCCESS, idx;
tdb_key = ltdb_key(module, msg->dn);
if (!tdb_key.dptr) {
msg2 = talloc(tdb_key.dptr, struct ldb_message);
if (msg2 == NULL) {
- talloc_free(tdb_key.dptr);
- return LDB_ERR_OTHER;
+ free(tdb_data.dptr);
+ ret = LDB_ERR_OTHER;
+ goto done;
}
ret = ltdb_unpack_data(module, &tdb_data, msg2);
+ free(tdb_data.dptr);
if (ret == -1) {
- talloc_free(tdb_key.dptr);
- free(tdb_data.dptr);
- return LDB_ERR_OTHER;
+ ret = LDB_ERR_OTHER;
+ goto done;
}
if (!msg2->dn) {
msg2->dn = msg->dn;
}
- for (i=0;i<msg->num_elements;i++) {
- struct ldb_message_element *el = &msg->elements[i];
- struct ldb_message_element *el2;
+ for (i=0; i<msg->num_elements; i++) {
+ struct ldb_message_element *el = &msg->elements[i], *el2;
struct ldb_val *vals;
- char *err_string;
- char *dn;
+ const struct ldb_schema_attribute *a = ldb_schema_attribute_by_name(ldb, el->name);
+ const char *dn;
+
+ if (ldb_attr_cmp(el->name, "distinguishedName") == 0) {
+ ldb_asprintf_errstring(ldb, "it is not permitted to perform a modify on 'distinguishedName' (use rename instead): %s",
+ ldb_dn_get_linearized(msg->dn));
+ ret = LDB_ERR_CONSTRAINT_VIOLATION;
+ goto done;
+ }
switch (msg->elements[i].flags & LDB_FLAG_MOD_MASK) {
-
case LDB_FLAG_MOD_ADD:
- /* add this element to the message. fail if it
- already exists */
- ret = find_element(msg2, el->name);
+ if (el->num_values == 0) {
+ ldb_asprintf_errstring(ldb, "attribute %s on %s specified, but with 0 values (illigal)",
+ el->name, ldb_dn_get_linearized(msg->dn));
+ ret = LDB_ERR_CONSTRAINT_VIOLATION;
+ goto done;
+ }
- if (ret == -1) {
+ if (a && a->flags & LDB_ATTR_FLAG_SINGLE_VALUE) {
+ if (el->num_values > 1) {
+ ldb_asprintf_errstring(ldb, "SINGLE-VALUE attribute %s on %s specified more than once",
+ el->name, ldb_dn_get_linearized(msg->dn));
+ ret = LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS;
+ goto done;
+ }
+ }
+
+ /* Checks if element already exists */
+ idx = find_element(msg2, el->name);
+ if (idx == -1) {
if (msg_add_element(ldb, msg2, el) != 0) {
ret = LDB_ERR_OTHER;
- goto failed;
+ goto done;
+ }
+ } else {
+ /* We cannot add another value on a existing one
+ if the attribute is single-valued */
+ if (a && a->flags & LDB_ATTR_FLAG_SINGLE_VALUE) {
+ ldb_asprintf_errstring(ldb, "SINGLE-VALUE attribute %s on %s specified more than once",
+ el->name, ldb_dn_get_linearized(msg->dn));
+ ret = LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS;
+ goto done;
}
- continue;
- }
- el2 = &msg2->elements[ret];
+ el2 = &(msg2->elements[idx]);
+
+ /* Check that values don't exist yet on multi-
+ valued attributes or aren't provided twice */
+ for (j=0; j<el->num_values; j++) {
+ if (ldb_msg_find_val(el2, &el->values[j]) != NULL) {
+ ldb_asprintf_errstring(ldb, "%s: value #%d already exists", el->name, j);
+ ret = LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS;
+ goto done;
+ }
+ if (ldb_msg_find_val(el, &el->values[j]) != &el->values[j]) {
+ ldb_asprintf_errstring(ldb, "%s: value #%d provided more than once", el->name, j);
+ ret = LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS;
+ goto done;
+ }
+ }
- /* An attribute with this name already exists, add all
- * values if they don't already exist. */
+ /* Now combine existing and new values to a new
+ attribute record */
+ vals = talloc_realloc(msg2->elements,
+ el2->values, struct ldb_val,
+ el2->num_values + el->num_values);
+ if (vals == NULL) {
+ ldb_oom(ldb);
+ ret = LDB_ERR_OTHER;
+ goto done;
+ }
- for (j=0;j<el->num_values;j++) {
- if (ldb_msg_find_val(el2, &el->values[j])) {
- err_string = talloc_strdup(module, "Type or value exists");
- if (err_string) ldb_set_errstring(module->ldb, err_string);
- ret = LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS;
- goto failed;
+ for (j=0; j<el->num_values; j++) {
+ vals[el2->num_values + j] =
+ ldb_val_dup(vals, &el->values[j]);
}
- }
- vals = talloc_realloc(msg2->elements, el2->values, struct ldb_val,
- el2->num_values + el->num_values);
+ el2->values = vals;
+ el2->num_values += el->num_values;
+ }
- if (vals == NULL)
- goto failed;
+ break;
- for (j=0;j<el->num_values;j++) {
- vals[el2->num_values + j] =
- ldb_val_dup(vals, &el->values[j]);
+ case LDB_FLAG_MOD_REPLACE:
+ if (a && a->flags & LDB_ATTR_FLAG_SINGLE_VALUE) {
+ if (el->num_values > 1) {
+ ldb_asprintf_errstring(ldb, "SINGLE-VALUE attribute %s on %s specified more than once",
+ el->name, ldb_dn_get_linearized(msg->dn));
+ ret = LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS;
+ goto done;
+ }
}
- el2->values = vals;
- el2->num_values += el->num_values;
+ for (j=0; j<el->num_values; j++) {
+ if (ldb_msg_find_val(el, &el->values[j]) != &el->values[j]) {
+ ldb_asprintf_errstring(ldb, "%s: value #%d provided more than once", el->name, j);
+ ret = LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS;
+ goto done;
+ }
+ }
- break;
+ /* Delete the attribute if it exists in the DB */
+ msg_delete_attribute(module, ldb, msg2, el->name);
- case LDB_FLAG_MOD_REPLACE:
- /* replace all elements of this attribute name with the elements
- listed. The attribute not existing is not an error */
- msg_delete_attribute(module, ldb, msg2, msg->elements[i].name);
-
- /* add the replacement element, if not empty */
- if (msg->elements[i].num_values != 0 &&
- msg_add_element(ldb, msg2, &msg->elements[i]) != 0) {
- goto failed;
+ /* Recreate it with the new values */
+ if (msg_add_element(ldb, msg2, el) != 0) {
+ ret = LDB_ERR_OTHER;
+ goto done;
}
+
break;
case LDB_FLAG_MOD_DELETE:
+ dn = ldb_dn_get_linearized(msg->dn);
+ if (dn == NULL) {
+ ret = LDB_ERR_OTHER;
+ goto done;
+ }
- dn = ldb_dn_linearize(msg2, msg->dn);
- if (dn == NULL) goto failed;
-
- /* we could be being asked to delete all
- values or just some values */
if (msg->elements[i].num_values == 0) {
- if (msg_delete_attribute(module, ldb, msg2,
+ /* Delete the whole attribute */
+ if (msg_delete_attribute(module, ldb, msg2,
msg->elements[i].name) != 0) {
- err_string = talloc_asprintf(module, "No such attribute: %s", msg->elements[i].name);
- if (err_string) ldb_set_errstring(module->ldb, err_string);
+ ldb_asprintf_errstring(ldb, "No such attribute: %s for delete on %s",
+ msg->elements[i].name, dn);
ret = LDB_ERR_NO_SUCH_ATTRIBUTE;
- goto failed;
+ goto done;
}
- break;
- }
- for (j=0;j<msg->elements[i].num_values;j++) {
- if (msg_delete_element(module,
- msg2,
- msg->elements[i].name,
- &msg->elements[i].values[j]) != 0) {
- err_string = talloc_asprintf(module, "No such attribute: %s", msg->elements[i].name);
- if (err_string) ldb_set_errstring(module->ldb, err_string);
- ret = LDB_ERR_NO_SUCH_ATTRIBUTE;
- goto failed;
- }
- if (ltdb_index_del_value(module, dn, &msg->elements[i], j) != 0) {
- goto failed;
+ } else {
+ /* Delete specified values from an attribute */
+ for (j=0; j < msg->elements[i].num_values; j++) {
+ if (msg_delete_element(module,
+ msg2,
+ msg->elements[i].name,
+ &msg->elements[i].values[j]) != 0) {
+ ldb_asprintf_errstring(ldb, "No matching attribute value when deleting attribute: %s on %s",
+ msg->elements[i].name, dn);
+ ret = LDB_ERR_NO_SUCH_ATTRIBUTE;
+ goto done;
+ }
+
+ ret = ltdb_index_del_value(module, dn,
+ &msg->elements[i], j);
+ if (ret != LDB_SUCCESS) {
+ goto done;
+ }
}
}
+
break;
default:
- err_string = talloc_asprintf(module, "Invalid ldb_modify flags on %s: 0x%x",
- msg->elements[i].name,
- msg->elements[i].flags & LDB_FLAG_MOD_MASK);
- if (err_string) ldb_set_errstring(module->ldb, err_string);
+ ldb_asprintf_errstring(ldb,
+ "Invalid ldb_modify flags on %s: 0x%x",
+ msg->elements[i].name,
+ msg->elements[i].flags & LDB_FLAG_MOD_MASK);
ret = LDB_ERR_PROTOCOL_ERROR;
- goto failed;
+ goto done;
}
}
- /* we've made all the mods - save the modified record back into the database */
ret = ltdb_store(module, msg2, TDB_MODIFY);
+ if (ret != LDB_SUCCESS) {
+ goto done;
+ }
- talloc_free(tdb_key.dptr);
- free(tdb_data.dptr);
- return ret;
+ ret = ltdb_modified(module, msg->dn);
+ if (ret != LDB_SUCCESS) {
+ goto done;
+ }
-failed:
+done:
talloc_free(tdb_key.dptr);
- free(tdb_data.dptr);
return ret;
}
/*
modify a record
*/
-static int ltdb_modify_async(struct ldb_module *module, const struct ldb_message *msg,
- void *context,
- int (*callback)(struct ldb_context *, void *, struct ldb_async_result *),
- struct ldb_async_handle **handle)
+static int ltdb_modify(struct ltdb_context *ctx)
{
- struct ltdb_private *ltdb = talloc_get_type(module->private_data, struct ltdb_private);
- struct ltdb_async_context *ltdb_ac;
- int tret, ret = LDB_SUCCESS;
+ struct ldb_module *module = ctx->module;
+ struct ldb_request *req = ctx->req;
+ int ret = LDB_SUCCESS;
+
+ ret = ltdb_check_special_dn(module, req->op.mod.message);
+ if (ret != LDB_SUCCESS) {
+ return ret;
+ }
- *handle = NULL;
+ ldb_request_set_state(req, LDB_ASYNC_PENDING);
- *handle = init_ltdb_handle(ltdb, module, context, callback);
- if (*handle == NULL) {
+ if (ltdb_cache_load(module) != 0) {
return LDB_ERR_OPERATIONS_ERROR;
}
- ltdb_ac = talloc_get_type((*handle)->private_data, struct ltdb_async_context);
- tret = ltdb_check_special_dn(module, msg);
- if (tret != LDB_SUCCESS) {
- (*handle)->status = tret;
- goto done;
+ ret = ltdb_modify_internal(module, req->op.mod.message);
+
+ return ret;
+}
+
+/*
+ rename a record
+*/
+static int ltdb_rename(struct ltdb_context *ctx)
+{
+ struct ldb_module *module = ctx->module;
+ struct ldb_request *req = ctx->req;
+ struct ldb_message *msg;
+ int ret = LDB_SUCCESS;
+
+ ldb_request_set_state(req, LDB_ASYNC_PENDING);
+
+ if (ltdb_cache_load(ctx->module) != 0) {
+ return LDB_ERR_OPERATIONS_ERROR;
}
-
- if (ltdb_cache_load(module) != 0) {
+
+ msg = talloc(ctx, struct ldb_message);
+ if (msg == NULL) {
ret = LDB_ERR_OPERATIONS_ERROR;
goto done;
}
- tret = ltdb_modify_internal(module, msg);
+ /* in case any attribute of the message was indexed, we need
+ to fetch the old record */
+ ret = ltdb_search_dn1(module, req->op.rename.olddn, msg);
+ if (ret != LDB_SUCCESS) {
+ /* not finding the old record is an error */
+ goto done;
+ }
- if (tret != LDB_SUCCESS) {
- (*handle)->status = tret;
+ msg->dn = ldb_dn_copy(msg, req->op.rename.newdn);
+ if (msg->dn == NULL) {
+ ret = LDB_ERR_OPERATIONS_ERROR;
goto done;
}
- ltdb_modified(module, msg->dn);
+ /* Always delete first then add, to avoid conflicts with
+ * unique indexes. We rely on the transaction to make this
+ * atomic
+ */
+ ret = ltdb_delete_internal(module, req->op.rename.olddn);
+ if (ret != LDB_SUCCESS) {
+ goto done;
+ }
- if (ltdb_ac->callback)
- ret = ltdb_ac->callback(module->ldb, ltdb_ac->context, NULL);
+ ret = ltdb_add_internal(module, msg);
done:
- (*handle)->state = LDB_ASYNC_DONE;
return ret;
}
-static int ltdb_modify(struct ldb_module *module, const struct ldb_message *msg)
+static int ltdb_start_trans(struct ldb_module *module)
{
- struct ldb_async_handle *handle;
- int ret;
+ void *data = ldb_module_get_private(module);
+ struct ltdb_private *ltdb = talloc_get_type(data, struct ltdb_private);
- ret = ltdb_modify_async(module, msg, NULL, NULL, &handle);
+ if (tdb_transaction_start(ltdb->tdb) != 0) {
+ return ltdb_err_map(tdb_error(ltdb->tdb));
+ }
- if (ret != LDB_SUCCESS)
- return ret;
+ ltdb->in_transaction++;
- ret = ldb_async_wait(handle, LDB_WAIT_ALL);
+ ltdb_index_transaction_start(module);
- talloc_free(handle);
- return ret;
+ return LDB_SUCCESS;
}
-/*
- rename a record
-*/
-static int ltdb_rename_async(struct ldb_module *module, const struct ldb_dn *olddn, const struct ldb_dn *newdn,
- void *context,
- int (*callback)(struct ldb_context *, void *, struct ldb_async_result *),
- struct ldb_async_handle **handle)
+static int ltdb_prepare_commit(struct ldb_module *module)
{
- struct ltdb_private *ltdb = talloc_get_type(module->private_data, struct ltdb_private);
- struct ltdb_async_context *ltdb_ac;
- struct ldb_message *msg;
- int tret, ret = LDB_SUCCESS;
+ void *data = ldb_module_get_private(module);
+ struct ltdb_private *ltdb = talloc_get_type(data, struct ltdb_private);
+
+ if (ltdb->in_transaction != 1) {
+ return LDB_SUCCESS;
+ }
- *handle = NULL;
+ if (ltdb_index_transaction_commit(module) != 0) {
+ tdb_transaction_cancel(ltdb->tdb);
+ ltdb->in_transaction--;
+ return ltdb_err_map(tdb_error(ltdb->tdb));
+ }
- if (ltdb_cache_load(module) != 0) {
+ if (tdb_transaction_prepare_commit(ltdb->tdb) != 0) {
+ ltdb->in_transaction--;
+ return ltdb_err_map(tdb_error(ltdb->tdb));
+ }
+
+ ltdb->prepared_commit = true;
+
+ return LDB_SUCCESS;
+}
+
+static int ltdb_end_trans(struct ldb_module *module)
+{
+ void *data = ldb_module_get_private(module);
+ struct ltdb_private *ltdb = talloc_get_type(data, struct ltdb_private);
+
+ if (!ltdb->prepared_commit) {
+ int ret = ltdb_prepare_commit(module);
+ if (ret != LDB_SUCCESS) {
+ return ret;
+ }
+ }
+
+ ltdb->in_transaction--;
+ ltdb->prepared_commit = false;
+
+ if (tdb_transaction_commit(ltdb->tdb) != 0) {
+ return ltdb_err_map(tdb_error(ltdb->tdb));
+ }
+
+ return LDB_SUCCESS;
+}
+
+static int ltdb_del_trans(struct ldb_module *module)
+{
+ void *data = ldb_module_get_private(module);
+ struct ltdb_private *ltdb = talloc_get_type(data, struct ltdb_private);
+
+ ltdb->in_transaction--;
+
+ if (ltdb_index_transaction_cancel(module) != 0) {
+ tdb_transaction_cancel(ltdb->tdb);
+ return ltdb_err_map(tdb_error(ltdb->tdb));
+ }
+
+ if (tdb_transaction_cancel(ltdb->tdb) != 0) {
+ return ltdb_err_map(tdb_error(ltdb->tdb));
+ }
+
+ return LDB_SUCCESS;
+}
+
+/*
+ return sequenceNumber from @BASEINFO
+*/
+static int ltdb_sequence_number(struct ltdb_context *ctx,
+ struct ldb_extended **ext)
+{
+ struct ldb_context *ldb;
+ struct ldb_module *module = ctx->module;
+ struct ldb_request *req = ctx->req;
+ TALLOC_CTX *tmp_ctx;
+ struct ldb_seqnum_request *seq;
+ struct ldb_seqnum_result *res;
+ struct ldb_message *msg = NULL;
+ struct ldb_dn *dn;
+ const char *date;
+ int ret = LDB_SUCCESS;
+
+ ldb = ldb_module_get_ctx(module);
+
+ seq = talloc_get_type(req->op.extended.data,
+ struct ldb_seqnum_request);
+ if (seq == NULL) {
return LDB_ERR_OPERATIONS_ERROR;
}
- *handle = init_ltdb_handle(ltdb, module, context, callback);
- if (*handle == NULL) {
+ ldb_request_set_state(req, LDB_ASYNC_PENDING);
+
+ if (ltdb_lock_read(module) != 0) {
return LDB_ERR_OPERATIONS_ERROR;
}
- ltdb_ac = talloc_get_type((*handle)->private_data, struct ltdb_async_context);
- msg = talloc(ltdb_ac, struct ldb_message);
- if (msg == NULL) {
+ res = talloc_zero(req, struct ldb_seqnum_result);
+ if (res == NULL) {
ret = LDB_ERR_OPERATIONS_ERROR;
goto done;
}
-
- /* in case any attribute of the message was indexed, we need
- to fetch the old record */
- tret = ltdb_search_dn1(module, olddn, msg);
- if (tret != 1) {
- /* not finding the old record is an error */
- (*handle)->status = LDB_ERR_NO_SUCH_OBJECT;
+ tmp_ctx = talloc_new(req);
+ if (tmp_ctx == NULL) {
+ ret = LDB_ERR_OPERATIONS_ERROR;
goto done;
}
- msg->dn = ldb_dn_copy(msg, newdn);
- if (!msg->dn) {
+ dn = ldb_dn_new(tmp_ctx, ldb, LTDB_BASEINFO);
+
+ msg = talloc(tmp_ctx, struct ldb_message);
+ if (msg == NULL) {
ret = LDB_ERR_OPERATIONS_ERROR;
goto done;
}
- tret = ltdb_add(module, msg);
- if (tret != LDB_SUCCESS) {
- ret = LDB_ERR_OPERATIONS_ERROR;
+ ret = ltdb_search_dn1(module, dn, msg);
+ if (ret != LDB_SUCCESS) {
goto done;
}
- tret = ltdb_delete(module, olddn);
- if (tret != LDB_SUCCESS) {
- ltdb_delete(module, newdn);
+ switch (seq->type) {
+ case LDB_SEQ_HIGHEST_SEQ:
+ res->seq_num = ldb_msg_find_attr_as_uint64(msg, LTDB_SEQUENCE_NUMBER, 0);
+ break;
+ case LDB_SEQ_NEXT:
+ res->seq_num = ldb_msg_find_attr_as_uint64(msg, LTDB_SEQUENCE_NUMBER, 0);
+ res->seq_num++;
+ break;
+ case LDB_SEQ_HIGHEST_TIMESTAMP:
+ date = ldb_msg_find_attr_as_string(msg, LTDB_MOD_TIMESTAMP, NULL);
+ if (date) {
+ res->seq_num = ldb_string_to_time(date);
+ } else {
+ res->seq_num = 0;
+ /* zero is as good as anything when we don't know */
+ }
+ break;
+ }
+
+ *ext = talloc_zero(req, struct ldb_extended);
+ if (*ext == NULL) {
ret = LDB_ERR_OPERATIONS_ERROR;
goto done;
}
-
- if (ltdb_ac->callback)
- ret = ltdb_ac->callback(module->ldb, ltdb_ac->context, NULL);
+ (*ext)->oid = LDB_EXTENDED_SEQUENCE_NUMBER;
+ (*ext)->data = talloc_steal(*ext, res);
done:
- (*handle)->state = LDB_ASYNC_DONE;
+ talloc_free(tmp_ctx);
+ ltdb_unlock_read(module);
return ret;
}
-static int ltdb_rename(struct ldb_module *module, const struct ldb_dn *olddn, const struct ldb_dn *newdn)
+static void ltdb_request_done(struct ltdb_context *ctx, int error)
{
- struct ldb_async_handle *handle;
- int ret;
+ struct ldb_context *ldb;
+ struct ldb_request *req;
+ struct ldb_reply *ares;
- ret = ltdb_rename_async(module, olddn, newdn, NULL, NULL, &handle);
+ ldb = ldb_module_get_ctx(ctx->module);
+ req = ctx->req;
- if (ret != LDB_SUCCESS)
- return ret;
+ /* if we already returned an error just return */
+ if (ldb_request_get_status(req) != LDB_SUCCESS) {
+ return;
+ }
- ret = ldb_async_wait(handle, LDB_WAIT_ALL);
+ ares = talloc_zero(req, struct ldb_reply);
+ if (!ares) {
+ ldb_oom(ldb);
+ req->callback(req, NULL);
+ return;
+ }
+ ares->type = LDB_REPLY_DONE;
+ ares->error = error;
- talloc_free(handle);
- return ret;
+ req->callback(req, ares);
}
-static int ltdb_start_trans(struct ldb_module *module)
+static void ltdb_timeout(struct tevent_context *ev,
+ struct tevent_timer *te,
+ struct timeval t,
+ void *private_data)
{
- struct ltdb_private *ltdb = module->private_data;
+ struct ltdb_context *ctx;
+ ctx = talloc_get_type(private_data, struct ltdb_context);
- if (tdb_transaction_start(ltdb->tdb) != 0) {
- return ltdb_err_map(tdb_error(ltdb->tdb));
+ if (!ctx->request_terminated) {
+ /* request is done now */
+ ltdb_request_done(ctx, LDB_ERR_TIME_LIMIT_EXCEEDED);
}
- return LDB_SUCCESS;
+ if (!ctx->request_terminated) {
+ /* neutralize the spy */
+ ctx->spy->ctx = NULL;
+ }
+ talloc_free(ctx);
}
-static int ltdb_end_trans(struct ldb_module *module)
+static void ltdb_request_extended_done(struct ltdb_context *ctx,
+ struct ldb_extended *ext,
+ int error)
{
- struct ltdb_private *ltdb = module->private_data;
+ struct ldb_context *ldb;
+ struct ldb_request *req;
+ struct ldb_reply *ares;
- if (tdb_transaction_commit(ltdb->tdb) != 0) {
- return ltdb_err_map(tdb_error(ltdb->tdb));
+ ldb = ldb_module_get_ctx(ctx->module);
+ req = ctx->req;
+
+ /* if we already returned an error just return */
+ if (ldb_request_get_status(req) != LDB_SUCCESS) {
+ return;
}
- return LDB_SUCCESS;
+ ares = talloc_zero(req, struct ldb_reply);
+ if (!ares) {
+ ldb_oom(ldb);
+ req->callback(req, NULL);
+ return;
+ }
+ ares->type = LDB_REPLY_DONE;
+ ares->response = ext;
+ ares->error = error;
+
+ req->callback(req, ares);
}
-static int ltdb_del_trans(struct ldb_module *module)
+static void ltdb_handle_extended(struct ltdb_context *ctx)
{
- struct ltdb_private *ltdb = module->private_data;
+ struct ldb_extended *ext = NULL;
+ int ret;
- if (tdb_transaction_cancel(ltdb->tdb) != 0) {
- return ltdb_err_map(tdb_error(ltdb->tdb));
+ if (strcmp(ctx->req->op.extended.oid,
+ LDB_EXTENDED_SEQUENCE_NUMBER) == 0) {
+ /* get sequence number */
+ ret = ltdb_sequence_number(ctx, &ext);
+ } else {
+ /* not recognized */
+ ret = LDB_ERR_UNSUPPORTED_CRITICAL_EXTENSION;
}
- return LDB_SUCCESS;
+ ltdb_request_extended_done(ctx, ext, ret);
}
-static int ltdb_async_wait(struct ldb_async_handle *handle, enum ldb_async_wait_type type)
+static void ltdb_callback(struct tevent_context *ev,
+ struct tevent_timer *te,
+ struct timeval t,
+ void *private_data)
{
- return handle->status;
+ struct ltdb_context *ctx;
+ int ret;
+
+ ctx = talloc_get_type(private_data, struct ltdb_context);
+
+ if (ctx->request_terminated) {
+ goto done;
+ }
+
+ switch (ctx->req->operation) {
+ case LDB_SEARCH:
+ ret = ltdb_search(ctx);
+ break;
+ case LDB_ADD:
+ ret = ltdb_add(ctx);
+ break;
+ case LDB_MODIFY:
+ ret = ltdb_modify(ctx);
+ break;
+ case LDB_DELETE:
+ ret = ltdb_delete(ctx);
+ break;
+ case LDB_RENAME:
+ ret = ltdb_rename(ctx);
+ break;
+ case LDB_EXTENDED:
+ ltdb_handle_extended(ctx);
+ goto done;
+ default:
+ /* no other op supported */
+ ret = LDB_ERR_UNWILLING_TO_PERFORM;
+ }
+
+ if (!ctx->request_terminated) {
+ /* request is done now */
+ ltdb_request_done(ctx, ret);
+ }
+
+done:
+ if (!ctx->request_terminated) {
+ /* neutralize the spy */
+ ctx->spy->ctx = NULL;
+ }
+ talloc_free(ctx);
}
-static int ltdb_request(struct ldb_module *module, struct ldb_request *req)
+static int ltdb_request_destructor(void *ptr)
{
- /* check for oustanding critical controls and return an error if found */
+ struct ltdb_req_spy *spy = talloc_get_type(ptr, struct ltdb_req_spy);
- if (req->controls != NULL) {
- ldb_debug(module->ldb, LDB_DEBUG_WARNING, "Controls should not reach the ldb_tdb backend!\n");
+ if (spy->ctx != NULL) {
+ spy->ctx->request_terminated = true;
}
+ return 0;
+}
+
+static int ltdb_handle_request(struct ldb_module *module,
+ struct ldb_request *req)
+{
+ struct ldb_context *ldb;
+ struct tevent_context *ev;
+ struct ltdb_context *ac;
+ struct tevent_timer *te;
+ struct timeval tv;
+
if (check_critical_controls(req->controls)) {
return LDB_ERR_UNSUPPORTED_CRITICAL_EXTENSION;
}
-
- switch (req->operation) {
-
- case LDB_REQ_SEARCH:
- return ltdb_search_bytree(module,
- req->op.search.base,
- req->op.search.scope,
- req->op.search.tree,
- req->op.search.attrs,
- &req->op.search.res);
-
- case LDB_REQ_ADD:
- return ltdb_add(module, req->op.add.message);
-
- case LDB_REQ_MODIFY:
- return ltdb_modify(module, req->op.mod.message);
-
- case LDB_REQ_DELETE:
- return ltdb_delete(module, req->op.del.dn);
-
- case LDB_REQ_RENAME:
- return ltdb_rename(module,
- req->op.rename.olddn,
- req->op.rename.newdn);
-
- case LDB_ASYNC_SEARCH:
- return ltdb_search_async(module,
- req->op.search.base,
- req->op.search.scope,
- req->op.search.tree,
- req->op.search.attrs,
- req->async.context,
- req->async.callback,
- &req->async.handle);
-
- case LDB_ASYNC_ADD:
- return ltdb_add_async(module,
- req->op.add.message,
- req->async.context,
- req->async.callback,
- &req->async.handle);
-
- case LDB_ASYNC_MODIFY:
- return ltdb_modify_async(module,
- req->op.mod.message,
- req->async.context,
- req->async.callback,
- &req->async.handle);
-
- case LDB_ASYNC_DELETE:
- return ltdb_delete_async(module,
- req->op.del.dn,
- req->async.context,
- req->async.callback,
- &req->async.handle);
-
- case LDB_ASYNC_RENAME:
- return ltdb_rename_async(module,
- req->op.rename.olddn,
- req->op.rename.newdn,
- req->async.context,
- req->async.callback,
- &req->async.handle);
- default:
+ ldb = ldb_module_get_ctx(module);
+
+ if (req->starttime == 0 || req->timeout == 0) {
+ ldb_set_errstring(ldb, "Invalid timeout settings");
+ return LDB_ERR_TIME_LIMIT_EXCEEDED;
+ }
+
+ ev = ldb_get_event_context(ldb);
+
+ ac = talloc_zero(ldb, struct ltdb_context);
+ if (ac == NULL) {
+ ldb_oom(ldb);
return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ ac->module = module;
+ ac->req = req;
+ tv.tv_sec = 0;
+ tv.tv_usec = 0;
+ te = tevent_add_timer(ev, ac, tv, ltdb_callback, ac);
+ if (NULL == te) {
+ talloc_free(ac);
+ return LDB_ERR_OPERATIONS_ERROR;
}
-}
-/*
- return sequenceNumber from @BASEINFO
-*/
-static uint64_t ltdb_sequence_number(struct ldb_context *ldb)
-{
- TALLOC_CTX *tmp_ctx = talloc_new(ldb);
- const char *attrs[] = { "sequenceNumber", NULL };
- struct ldb_result *res = NULL;
- struct ldb_dn *dn = ldb_dn_explode(tmp_ctx, "@BASEINFO");
- int ret;
- uint64_t seq_num;
+ tv.tv_sec = req->starttime + req->timeout;
+ ac->timeout_event = tevent_add_timer(ev, ac, tv, ltdb_timeout, ac);
+ if (NULL == ac->timeout_event) {
+ talloc_free(ac);
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
- ret = ldb_search(ldb, dn, LDB_SCOPE_BASE, NULL, attrs, &res);
- talloc_steal(tmp_ctx, res);
- if (ret != LDB_SUCCESS || res->count != 1) {
- talloc_free(tmp_ctx);
- /* zero is as good as anything when we don't know */
- return 0;
+ /* set a spy so that we do not try to use the request context
+ * if it is freed before ltdb_callback fires */
+ ac->spy = talloc(req, struct ltdb_req_spy);
+ if (NULL == ac->spy) {
+ talloc_free(ac);
+ return LDB_ERR_OPERATIONS_ERROR;
}
+ ac->spy->ctx = ac;
- seq_num = ldb_msg_find_uint64(res->msgs[0], "sequenceNumber", 0);
- talloc_free(tmp_ctx);
- return seq_num;
+ talloc_set_destructor((TALLOC_CTX *)ac->spy, ltdb_request_destructor);
+
+ return LDB_SUCCESS;
}
static const struct ldb_module_ops ltdb_ops = {
.name = "tdb",
- .request = ltdb_request,
+ .search = ltdb_handle_request,
+ .add = ltdb_handle_request,
+ .modify = ltdb_handle_request,
+ .del = ltdb_handle_request,
+ .rename = ltdb_handle_request,
+ .extended = ltdb_handle_request,
.start_transaction = ltdb_start_trans,
.end_transaction = ltdb_end_trans,
+ .prepare_commit = ltdb_prepare_commit,
.del_transaction = ltdb_del_trans,
- .async_wait = ltdb_async_wait
};
-
/*
connect to the database
*/
-static int ltdb_connect(struct ldb_context *ldb, const char *url,
- unsigned int flags, const char *options[])
+static int ltdb_connect(struct ldb_context *ldb, const char *url,
+ unsigned int flags, const char *options[],
+ struct ldb_module **_module)
{
+ struct ldb_module *module;
const char *path;
int tdb_flags, open_flags;
struct ltdb_private *ltdb;
/* parse the url */
if (strchr(url, ':')) {
if (strncmp(url, "tdb://", 6) != 0) {
- ldb_debug(ldb, LDB_DEBUG_ERROR, "Invalid tdb URL '%s'", url);
+ ldb_debug(ldb, LDB_DEBUG_ERROR,
+ "Invalid tdb URL '%s'", url);
return -1;
}
path = url+6;
path = url;
}
- tdb_flags = TDB_DEFAULT;
+ tdb_flags = TDB_DEFAULT | TDB_SEQNUM;
/* check for the 'nosync' option */
if (flags & LDB_FLG_NOSYNC) {
tdb_flags |= TDB_NOSYNC;
}
+ /* and nommap option */
+ if (flags & LDB_FLG_NOMMAP) {
+ tdb_flags |= TDB_NOMMAP;
+ }
+
if (flags & LDB_FLG_RDONLY) {
open_flags = O_RDONLY;
} else {
}
/* note that we use quite a large default hash size */
- ltdb->tdb = ltdb_wrap_open(ltdb, path, 10000, tdb_flags, open_flags, 0666);
+ ltdb->tdb = ltdb_wrap_open(ltdb, path, 10000,
+ tdb_flags, open_flags,
+ ldb_get_create_perms(ldb), ldb);
if (!ltdb->tdb) {
- ldb_debug(ldb, LDB_DEBUG_ERROR, "Unable to open tdb '%s'\n", path);
+ ldb_debug(ldb, LDB_DEBUG_ERROR,
+ "Unable to open tdb '%s'", path);
talloc_free(ltdb);
return -1;
}
ltdb->sequence_number = 0;
- ldb->modules = talloc(ldb, struct ldb_module);
- if (!ldb->modules) {
- ldb_oom(ldb);
+ module = ldb_module_new(ldb, ldb, "ldb_tdb backend", <db_ops);
+ if (!module) {
+ talloc_free(ltdb);
+ return -1;
+ }
+ ldb_module_set_private(module, ltdb);
+
+ if (ltdb_cache_load(module) != 0) {
+ talloc_free(module);
talloc_free(ltdb);
return -1;
}
- ldb->modules->ldb = ldb;
- ldb->modules->prev = ldb->modules->next = NULL;
- ldb->modules->private_data = ltdb;
- ldb->modules->ops = <db_ops;
- ldb->sequence_number = ltdb_sequence_number;
+ *_module = module;
return 0;
}
-int ldb_tdb_init(void)
-{
- return ldb_register_backend("tdb", ltdb_connect);
-}
+const struct ldb_backend_ops ldb_tdb_backend_ops = {
+ .name = "tdb",
+ .connect_fn = ltdb_connect
+};