ldb database library
Copyright (C) Andrew Tridgell 2004
+ Copyright (C) Stefan Metzmacher 2004
+ Copyright (C) Simo Sorce 2006
+
** NOTE! The following LGPL license applies to the ldb
** library. This does NOT imply that all of Samba is released
*/
/*
- * Name: ldb
+ * Name: ldb_tdb
*
* Component: ldb tdb backend
*
* Description: core functions for tdb backend
*
* Author: Andrew Tridgell
+ * Author: Stefan Metzmacher
+ *
+ * Modifications:
+ *
+ * - description: make the module use asyncronous calls
+ * date: Feb 2006
+ * Author: Simo Sorce
*/
#include "includes.h"
-#include "ldb_tdb/ldb_tdb.h"
+#include "ldb/include/includes.h"
+
+#include "ldb/ldb_tdb/ldb_tdb.h"
+
+
+/*
+ map a tdb error code to a ldb error code
+*/
+static int ltdb_err_map(enum TDB_ERROR tdb_code)
+{
+ switch (tdb_code) {
+ case TDB_SUCCESS:
+ return LDB_SUCCESS;
+ case TDB_ERR_CORRUPT:
+ case TDB_ERR_OOM:
+ case TDB_ERR_EINVAL:
+ return LDB_ERR_OPERATIONS_ERROR;
+ case TDB_ERR_IO:
+ return LDB_ERR_PROTOCOL_ERROR;
+ case TDB_ERR_LOCK:
+ case TDB_ERR_NOLOCK:
+ return LDB_ERR_BUSY;
+ case TDB_ERR_LOCK_TIMEOUT:
+ return LDB_ERR_TIME_LIMIT_EXCEEDED;
+ case TDB_ERR_EXISTS:
+ return LDB_ERR_ENTRY_ALREADY_EXISTS;
+ case TDB_ERR_NOEXIST:
+ return LDB_ERR_NO_SUCH_OBJECT;
+ case TDB_ERR_RDONLY:
+ return LDB_ERR_INSUFFICIENT_ACCESS_RIGHTS;
+ }
+ 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 *))
+{
+ 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;
+ }
+
+ 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;
+ }
+
+ 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;
+}
/*
form a TDB_DATA for a record key
caller frees
+
+ 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(const char *dn)
+struct TDB_DATA ltdb_key(struct ldb_module *module, const struct ldb_dn *dn)
{
+ struct ldb_context *ldb = module->ldb;
TDB_DATA key;
char *key_str = NULL;
+ char *dn_folded = NULL;
+
+ /*
+ most DNs are case insensitive. The exception is index DNs for
+ case sensitive attributes
+
+ there are 3 cases dealt with in this code:
+
+ 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
+ */
+
+ dn_folded = ldb_dn_linearize_casefold(ldb, dn);
+ if (!dn_folded) {
+ goto failed;
+ }
+
+ key_str = talloc_asprintf(ldb, "DN=%s", dn_folded);
+
+ talloc_free(dn_folded);
- asprintf(&key_str, "DN=%s", dn);
if (!key_str) {
- errno = ENOMEM;
- key.dptr = NULL;
- key.dsize = 0;
- return key;
+ goto failed;
}
- key.dptr = key_str;
- key.dsize = strlen(key_str)+1;
+ key.dptr = (uint8_t *)key_str;
+ key.dsize = strlen(key_str) + 1;
return key;
+
+failed:
+ errno = ENOMEM;
+ key.dptr = NULL;
+ key.dsize = 0;
+ return key;
+}
+
+/*
+ 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)
+{
+ int i, j;
+
+ if (! ldb_dn_is_special(msg->dn) ||
+ ! ldb_dn_check_special(msg->dn, LTDB_ATTRIBUTES)) {
+ return 0;
+ }
+
+ /* we have @ATTRIBUTES, let's check attributes are fine */
+ /* should we check that we deny multivalued attributes ? */
+ 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);
+ }
+ return LDB_ERR_INVALID_ATTRIBUTE_SYNTAX;
+ }
+ }
+ }
+
+ return 0;
}
+/*
+ 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)
+{
+ int ret = 0;
+
+ if (ldb_dn_is_special(dn) &&
+ (ldb_dn_check_special(dn, LTDB_INDEXLIST) ||
+ ldb_dn_check_special(dn, LTDB_ATTRIBUTES)) ) {
+ ret = ltdb_reindex(module);
+ }
+
+ if (ret == 0 &&
+ !(ldb_dn_is_special(dn) &&
+ ldb_dn_check_special(dn, LTDB_BASEINFO)) ) {
+ ret = ltdb_increase_sequence_number(module);
+ }
+
+ return ret;
+}
+
/*
store a record into the db
*/
-int ltdb_store(struct ldb_context *ldb, const struct ldb_message *msg, int flgs)
+int ltdb_store(struct ldb_module *module, const struct ldb_message *msg, int flgs)
{
- struct ltdb_private *ltdb = ldb->private;
+ struct ltdb_private *ltdb = module->private_data;
TDB_DATA tdb_key, tdb_data;
int ret;
- tdb_key = ltdb_key(msg->dn);
+ tdb_key = ltdb_key(module, msg->dn);
if (!tdb_key.dptr) {
- return -1;
+ return LDB_ERR_OTHER;
}
- ret = ltdb_pack_data(ldb, msg, &tdb_data);
+ ret = ltdb_pack_data(module, msg, &tdb_data);
if (ret == -1) {
- free(tdb_key.dptr);
- return -1;
+ talloc_free(tdb_key.dptr);
+ return LDB_ERR_OTHER;
}
ret = tdb_store(ltdb->tdb, tdb_key, tdb_data, flgs);
if (ret == -1) {
+ ret = ltdb_err_map(tdb_error(ltdb->tdb));
goto done;
}
- ret = ltdb_index_add(ldb, msg);
+ ret = ltdb_index_add(module, msg);
if (ret == -1) {
tdb_delete(ltdb->tdb, tdb_key);
}
done:
- free(tdb_key.dptr);
- free(tdb_data.dptr);
+ talloc_free(tdb_key.dptr);
+ talloc_free(tdb_data.dptr);
return ret;
}
+static int ltdb_add_internal(struct ldb_module *module, const struct ldb_message *msg)
+{
+ int ret;
+
+ ret = ltdb_check_special_dn(module, msg);
+ if (ret != LDB_SUCCESS) {
+ return ret;
+ }
+
+ if (ltdb_cache_load(module) != 0) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ ret = ltdb_store(module, msg, TDB_INSERT);
+ if (ret != LDB_SUCCESS) {
+ return ret;
+ }
+
+ ret = ltdb_modified(module, msg->dn);
+ if (ret != LDB_SUCCESS) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ return LDB_SUCCESS;
+}
+
/*
add a record to the database
*/
-static int ltdb_add(struct ldb_context *ldb, const struct ldb_message *msg)
+static int ltdb_add(struct ldb_module *module, struct ldb_request *req)
{
- return ltdb_store(ldb, msg, TDB_INSERT);
-}
+ struct ltdb_private *ltdb = talloc_get_type(module->private_data, struct ltdb_private);
+ struct ltdb_async_context *ltdb_ac;
+ int tret, ret = LDB_SUCCESS;
+ if (req->controls != NULL) {
+ ldb_debug(module->ldb, LDB_DEBUG_WARNING, "Controls should not reach the ldb_tdb backend!\n");
+ if (check_critical_controls(req->controls)) {
+ return LDB_ERR_UNSUPPORTED_CRITICAL_EXTENSION;
+ }
+ }
+
+ req->async.handle = init_ltdb_handle(ltdb, module, req->async.context, req->async.callback);
+ if (req->async.handle == NULL) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+ ltdb_ac = talloc_get_type(req->async.handle->private_data, struct ltdb_async_context);
+
+ tret = ltdb_add_internal(module, req->op.add.message);
+ if (tret != LDB_SUCCESS) {
+ req->async.handle->status = tret;
+ goto done;
+ }
+
+ if (ltdb_ac->callback) {
+ ret = ltdb_ac->callback(module->ldb, ltdb_ac->context, NULL);
+ }
+done:
+ req->async.handle->state = LDB_ASYNC_DONE;
+ return ret;
+}
/*
delete a record from the database, not updating indexes (used for deleting
index records)
*/
-int ltdb_delete_noindex(struct ldb_context *ldb, const char *dn)
+int ltdb_delete_noindex(struct ldb_module *module, const struct ldb_dn *dn)
{
- struct ltdb_private *ltdb = ldb->private;
+ struct ltdb_private *ltdb = module->private_data;
TDB_DATA tdb_key;
int ret;
- tdb_key = ltdb_key(dn);
+ tdb_key = ltdb_key(module, dn);
if (!tdb_key.dptr) {
- return -1;
+ return LDB_ERR_OTHER;
}
ret = tdb_delete(ltdb->tdb, tdb_key);
- free(tdb_key.dptr);
+ talloc_free(tdb_key.dptr);
+
+ if (ret != 0) {
+ ret = ltdb_err_map(tdb_error(ltdb->tdb));
+ }
return ret;
}
-/*
- delete a record from the database
-*/
-static int ltdb_delete(struct ldb_context *ldb, const char *dn)
+static int ltdb_delete_internal(struct ldb_module *module, const struct ldb_dn *dn)
{
+ struct ldb_message *msg;
int ret;
- struct ldb_message msg;
+
+ msg = talloc(module, struct ldb_message);
+ if (msg == NULL) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
/* in case any attribute of the message was indexed, we need
to fetch the old record */
- ret = ltdb_search_dn1(ldb, dn, &msg);
+ ret = ltdb_search_dn1(module, dn, msg);
if (ret != 1) {
/* not finding the old record is an error */
- return -1;
+ talloc_free(msg);
+ return LDB_ERR_NO_SUCH_OBJECT;
}
- ret = ltdb_delete_noindex(ldb, dn);
- if (ret == -1) {
- ltdb_search_dn1_free(ldb, &msg);
- return -1;
+ ret = ltdb_delete_noindex(module, dn);
+ if (ret != LDB_SUCCESS) {
+ talloc_free(msg);
+ return LDB_ERR_NO_SUCH_OBJECT;
}
/* remove any indexed attributes */
- ret = ltdb_index_del(ldb, &msg);
+ ret = ltdb_index_del(module, msg);
+ if (ret != LDB_SUCCESS) {
+ talloc_free(msg);
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ ret = ltdb_modified(module, dn);
+ if (ret != LDB_SUCCESS) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ talloc_free(msg);
+ return LDB_SUCCESS;
+}
+
+/*
+ delete a record from the database
+*/
+static int ltdb_delete(struct ldb_module *module, struct ldb_request *req)
+{
+ struct ltdb_private *ltdb = talloc_get_type(module->private_data, struct ltdb_private);
+ struct ltdb_async_context *ltdb_ac;
+ int tret, ret = LDB_SUCCESS;
- ltdb_search_dn1_free(ldb, &msg);
+ if (req->controls != NULL) {
+ ldb_debug(module->ldb, LDB_DEBUG_WARNING, "Controls should not reach the ldb_tdb backend!\n");
+ if (check_critical_controls(req->controls)) {
+ return LDB_ERR_UNSUPPORTED_CRITICAL_EXTENSION;
+ }
+ }
+
+ req->async.handle = NULL;
+
+ if (ltdb_cache_load(module) != 0) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ req->async.handle = init_ltdb_handle(ltdb, module, req->async.context, req->async.callback);
+ if (req->async.handle == NULL) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+ ltdb_ac = talloc_get_type(req->async.handle->private_data, struct ltdb_async_context);
+ tret = ltdb_delete_internal(module, req->op.del.dn);
+ if (tret != LDB_SUCCESS) {
+ req->async.handle->status = tret;
+ goto done;
+ }
+
+ if (ltdb_ac->callback) {
+ ret = ltdb_ac->callback(module->ldb, ltdb_ac->context, NULL);
+ }
+done:
+ req->async.handle->state = LDB_ASYNC_DONE;
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
+
+ return the index of the first matching element if found, otherwise -1
+*/
+static int find_element(const struct ldb_message *msg, const char *name)
+{
+ unsigned int i;
+ for (i=0;i<msg->num_elements;i++) {
+ if (ldb_attr_cmp(msg->elements[i].name, name) == 0) {
+ return i;
+ }
+ }
+ return -1;
+}
+
/*
- modify a record
+ 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!
+
+ 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_element *e2;
+ unsigned int i;
+
+ e2 = talloc_realloc(msg, msg->elements, struct ldb_message_element,
+ msg->num_elements+1);
+ if (!e2) {
+ errno = ENOMEM;
+ return -1;
+ }
+
+ msg->elements = e2;
+
+ e2 = &msg->elements[msg->num_elements];
+
+ 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;
+ }
+ }
+ for (i=0;i<el->num_values;i++) {
+ e2->values[i] = el->values[i];
+ }
+ e2->num_values = el->num_values;
+
+ msg->num_elements++;
+
+ return 0;
+}
+
+/*
+ delete all elements having a specified attribute name
*/
-static int ltdb_modify(struct ldb_context *ldb, const struct ldb_message *msg)
+static int msg_delete_attribute(struct ldb_module *module,
+ struct ldb_context *ldb,
+ struct ldb_message *msg, const char *name)
{
- struct ltdb_private *ltdb = ldb->private;
+ char *dn;
+ unsigned int i, j;
+
+ dn = ldb_dn_linearize(ldb, 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);
+ }
+ talloc_free(msg->elements[i].values);
+ if (msg->num_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);
+ }
+ }
+
+ talloc_free(dn);
+ return 0;
+}
+
+/*
+ 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,
+ const char *name,
+ const struct ldb_val *val)
+{
+ struct ldb_context *ldb = module->ldb;
+ unsigned int i;
+ int found;
+ struct ldb_message_element *el;
+ const struct ldb_attrib_handler *h;
+
+ found = find_element(msg, name);
+ if (found == -1) {
+ return -1;
+ }
+
+ el = &msg->elements[found];
+
+ h = ldb_attrib_handler(ldb, el->name);
+
+ for (i=0;i<el->num_values;i++) {
+ if (h->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)));
+ }
+ el->num_values--;
+ if (el->num_values == 0) {
+ return msg_delete_attribute(module, ldb, msg, name);
+ }
+ return 0;
+ }
+ }
+
+ 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
+ then we'll need to look at this again
+*/
+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;
TDB_DATA tdb_key, tdb_data;
- struct ldb_message msg2;
+ struct ldb_message *msg2;
+ unsigned i, j;
int ret;
- tdb_key = ltdb_key(msg->dn);
+ tdb_key = ltdb_key(module, msg->dn);
if (!tdb_key.dptr) {
- return -1;
+ return LDB_ERR_OTHER;
}
tdb_data = tdb_fetch(ltdb->tdb, tdb_key);
if (!tdb_data.dptr) {
- free(tdb_key.dptr);
- return -1;
+ talloc_free(tdb_key.dptr);
+ return ltdb_err_map(tdb_error(ltdb->tdb));
+ }
+
+ msg2 = talloc(tdb_key.dptr, struct ldb_message);
+ if (msg2 == NULL) {
+ talloc_free(tdb_key.dptr);
+ return LDB_ERR_OTHER;
}
- ret = ltdb_unpack_data(ldb, &tdb_data, &msg2);
+ ret = ltdb_unpack_data(module, &tdb_data, msg2);
if (ret == -1) {
- free(tdb_key.dptr);
- free(tdb_data.dptr);
- return -1;
+ ret = LDB_ERR_OTHER;
+ goto failed;
+ }
+
+ if (!msg2->dn) {
+ msg2->dn = msg->dn;
}
-#if 0
for (i=0;i<msg->num_elements;i++) {
+ struct ldb_message_element *el = &msg->elements[i];
+ struct ldb_message_element *el2;
+ struct ldb_val *vals;
+ char *err_string;
+ char *dn;
+
switch (msg->elements[i].flags & LDB_FLAG_MOD_MASK) {
+
case LDB_FLAG_MOD_ADD:
- ret = find_element(&msg2, msg->elements[i].name);
- if (ret != -1) {
- errno = EEXIST;
+ /* add this element to the message. fail if it
+ already exists */
+ ret = find_element(msg2, el->name);
+
+ if (ret == -1) {
+ if (msg_add_element(ldb, msg2, el) != 0) {
+ ret = LDB_ERR_OTHER;
+ goto failed;
+ }
+ continue;
+ }
+
+ el2 = &msg2->elements[ret];
+
+ /* An attribute with this name already exists, add all
+ * values if they don't already exist. */
+
+ 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;
+ }
+ }
+
+ vals = talloc_realloc(msg2->elements, el2->values, struct ldb_val,
+ el2->num_values + el->num_values);
+
+ if (vals == NULL) {
+ ret = LDB_ERR_OTHER;
+ goto failed;
+ }
+
+ for (j=0;j<el->num_values;j++) {
+ vals[el2->num_values + j] =
+ ldb_val_dup(vals, &el->values[j]);
+ }
+
+ el2->values = vals;
+ el2->num_values += el->num_values;
+
+ break;
+
+ 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) {
+ ret = LDB_ERR_OTHER;
goto failed;
}
-
+ break;
+
+ case LDB_FLAG_MOD_DELETE:
+
+ dn = ldb_dn_linearize(msg2, msg->dn);
+ if (dn == NULL) {
+ ret = LDB_ERR_OTHER;
+ 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,
+ 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);
+ ret = LDB_ERR_NO_SUCH_ATTRIBUTE;
+ goto failed;
+ }
+ 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) {
+ ret = LDB_ERR_OTHER;
+ goto failed;
+ }
+ }
+ 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);
+ ret = LDB_ERR_PROTOCOL_ERROR;
+ goto failed;
}
}
-failed:
-#endif
+ /* 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 failed;
+ }
+
+ if (ltdb_modified(module, msg->dn) != LDB_SUCCESS) {
+ ret = LDB_ERR_OPERATIONS_ERROR;
+ goto failed;
+ }
- free(tdb_key.dptr);
+ talloc_free(tdb_key.dptr);
free(tdb_data.dptr);
- if (msg2.elements) free(msg2.elements);
-
- return -1;
+ return ret;
+
+failed:
+ talloc_free(tdb_key.dptr);
+ free(tdb_data.dptr);
+ return ret;
}
/*
- close database
+ modify a record
*/
-static int ltdb_close(struct ldb_context *ldb)
+static int ltdb_modify(struct ldb_module *module, struct ldb_request *req)
{
- struct ltdb_private *ltdb = ldb->private;
- int ret;
- ret = tdb_close(ltdb->tdb);
- free(ltdb);
- free(ldb);
+ struct ltdb_private *ltdb = talloc_get_type(module->private_data, struct ltdb_private);
+ struct ltdb_async_context *ltdb_ac;
+ int tret, ret = LDB_SUCCESS;
+
+ if (req->controls != NULL) {
+ ldb_debug(module->ldb, LDB_DEBUG_WARNING, "Controls should not reach the ldb_tdb backend!\n");
+ if (check_critical_controls(req->controls)) {
+ return LDB_ERR_UNSUPPORTED_CRITICAL_EXTENSION;
+ }
+ }
+
+ req->async.handle = NULL;
+
+ req->async.handle = init_ltdb_handle(ltdb, module, req->async.context, req->async.callback);
+ if (req->async.handle == NULL) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+ ltdb_ac = talloc_get_type(req->async.handle->private_data, struct ltdb_async_context);
+
+ tret = ltdb_check_special_dn(module, req->op.mod.message);
+ if (tret != LDB_SUCCESS) {
+ req->async.handle->status = tret;
+ goto done;
+ }
+
+ if (ltdb_cache_load(module) != 0) {
+ ret = LDB_ERR_OPERATIONS_ERROR;
+ goto done;
+ }
+
+ tret = ltdb_modify_internal(module, req->op.mod.message);
+ if (tret != LDB_SUCCESS) {
+ req->async.handle->status = tret;
+ goto done;
+ }
+
+ if (ltdb_ac->callback) {
+ ret = ltdb_ac->callback(module->ldb, ltdb_ac->context, NULL);
+ }
+done:
+ req->async.handle->state = LDB_ASYNC_DONE;
return ret;
}
-
/*
- return extended error information
+ rename a record
*/
-static const char *ltdb_errstring(struct ldb_context *ldb)
+static int ltdb_rename(struct ldb_module *module, struct ldb_request *req)
+{
+ 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;
+
+ if (req->controls != NULL) {
+ ldb_debug(module->ldb, LDB_DEBUG_WARNING, "Controls should not reach the ldb_tdb backend!\n");
+ if (check_critical_controls(req->controls)) {
+ return LDB_ERR_UNSUPPORTED_CRITICAL_EXTENSION;
+ }
+ }
+
+ req->async.handle = NULL;
+
+ if (ltdb_cache_load(module) != 0) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ req->async.handle = init_ltdb_handle(ltdb, module, req->async.context, req->async.callback);
+ if (req->async.handle == NULL) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+ ltdb_ac = talloc_get_type(req->async.handle->private_data, struct ltdb_async_context);
+
+ msg = talloc(ltdb_ac, struct ldb_message);
+ if (msg == 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, req->op.rename.olddn, msg);
+ if (tret != 1) {
+ /* not finding the old record is an error */
+ req->async.handle->status = LDB_ERR_NO_SUCH_OBJECT;
+ goto done;
+ }
+
+ msg->dn = ldb_dn_copy(msg, req->op.rename.newdn);
+ if (!msg->dn) {
+ ret = LDB_ERR_OPERATIONS_ERROR;
+ goto done;
+ }
+
+ tret = ltdb_add_internal(module, msg);
+ if (tret != LDB_SUCCESS) {
+ ret = LDB_ERR_OPERATIONS_ERROR;
+ goto done;
+ }
+
+ tret = ltdb_delete_internal(module, req->op.rename.olddn);
+ if (tret != LDB_SUCCESS) {
+ ltdb_delete_internal(module, req->op.rename.newdn);
+ ret = LDB_ERR_OPERATIONS_ERROR;
+ goto done;
+ }
+
+ if (ltdb_ac->callback) {
+ ret = ltdb_ac->callback(module->ldb, ltdb_ac->context, NULL);
+ }
+done:
+ req->async.handle->state = LDB_ASYNC_DONE;
+ return ret;
+}
+
+static int ltdb_start_trans(struct ldb_module *module)
{
- struct ltdb_private *ltdb = ldb->private;
- return tdb_errorstr(ltdb->tdb);
+ struct ltdb_private *ltdb = module->private_data;
+
+ if (tdb_transaction_start(ltdb->tdb) != 0) {
+ return ltdb_err_map(tdb_error(ltdb->tdb));
+ }
+
+ return LDB_SUCCESS;
}
+static int ltdb_end_trans(struct ldb_module *module)
+{
+ struct ltdb_private *ltdb = module->private_data;
-static const struct ldb_backend_ops ltdb_ops = {
- ltdb_close,
- ltdb_search,
- ltdb_search_free,
- ltdb_add,
- ltdb_modify,
- ltdb_delete,
- ltdb_errstring
-};
+ 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)
+{
+ struct ltdb_private *ltdb = module->private_data;
+
+ if (tdb_transaction_cancel(ltdb->tdb) != 0) {
+ return ltdb_err_map(tdb_error(ltdb->tdb));
+ }
+
+ return LDB_SUCCESS;
+}
+
+static int ltdb_async_wait(struct ldb_async_handle *handle, enum ldb_async_wait_type type)
+{
+ return handle->status;
+}
+
+static int ltdb_request(struct ldb_module *module, struct ldb_request *req)
+{
+ /* check for oustanding critical controls and return an error if found */
+ if (req->controls != NULL) {
+ ldb_debug(module->ldb, LDB_DEBUG_WARNING, "Controls should not reach the ldb_tdb backend!\n");
+ if (check_critical_controls(req->controls)) {
+ return LDB_ERR_UNSUPPORTED_CRITICAL_EXTENSION;
+ }
+ }
+
+ /* search, add, modify, delete, rename are handled by their own, no other op supported */
+ return LDB_ERR_OPERATIONS_ERROR;
+}
+
+/*
+ return sequenceNumber from @BASEINFO
+*/
+static int ltdb_sequence_number(struct ldb_module *module, struct ldb_request *req)
+{
+ TALLOC_CTX *tmp_ctx = talloc_new(req);
+ struct ldb_message *msg = NULL;
+ struct ldb_dn *dn = ldb_dn_explode(tmp_ctx, "@BASEINFO");
+ int tret;
+
+ if (tmp_ctx == NULL) {
+ talloc_free(tmp_ctx);
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ msg = talloc(tmp_ctx, struct ldb_message);
+ if (msg == NULL) {
+ talloc_free(tmp_ctx);
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ tret = ltdb_search_dn1(module, dn, msg);
+ if (tret != 1) {
+ talloc_free(tmp_ctx);
+ req->op.seq_num.seq_num = 0;
+ /* zero is as good as anything when we don't know */
+ return LDB_SUCCESS;
+ }
+
+ req->op.seq_num.seq_num = ldb_msg_find_uint64(msg, "sequenceNumber", 0);
+ talloc_free(tmp_ctx);
+ return LDB_SUCCESS;
+}
+static const struct ldb_module_ops ltdb_ops = {
+ .name = "tdb",
+ .search = ltdb_search,
+ .add = ltdb_add,
+ .modify = ltdb_modify,
+ .del = ltdb_delete,
+ .rename = ltdb_rename,
+ .request = ltdb_request,
+ .start_transaction = ltdb_start_trans,
+ .end_transaction = ltdb_end_trans,
+ .del_transaction = ltdb_del_trans,
+ .async_wait = ltdb_async_wait,
+ .sequence_number = ltdb_sequence_number
+};
/*
connect to the database
*/
-struct ldb_context *ltdb_connect(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)
{
const char *path;
int tdb_flags, open_flags;
struct ltdb_private *ltdb;
- TDB_CONTEXT *tdb;
- struct ldb_context *ldb;
/* parse the url */
- if (strncmp(url, "tdb://", 6) != 0) {
- errno = EINVAL;
- return NULL;
+ if (strchr(url, ':')) {
+ if (strncmp(url, "tdb://", 6) != 0) {
+ ldb_debug(ldb, LDB_DEBUG_ERROR, "Invalid tdb URL '%s'", url);
+ return -1;
+ }
+ path = url+6;
+ } else {
+ path = url;
}
- path = url+6;
-
tdb_flags = TDB_DEFAULT;
+ /* check for the 'nosync' option */
+ if (flags & LDB_FLG_NOSYNC) {
+ tdb_flags |= TDB_NOSYNC;
+ }
+
if (flags & LDB_FLG_RDONLY) {
open_flags = O_RDONLY;
} else {
open_flags = O_CREAT | O_RDWR;
}
- tdb = tdb_open(path, 0, tdb_flags, open_flags, 0666);
- if (!tdb) {
- return NULL;
+ ltdb = talloc_zero(ldb, struct ltdb_private);
+ if (!ltdb) {
+ ldb_oom(ldb);
+ return -1;
}
- ltdb = malloc_p(struct ltdb_private);
- if (!ltdb) {
- tdb_close(tdb);
- errno = ENOMEM;
- return NULL;
+ /* note that we use quite a large default hash size */
+ ltdb->tdb = ltdb_wrap_open(ltdb, path, 10000,
+ tdb_flags, open_flags, 0666, ldb);
+ if (!ltdb->tdb) {
+ ldb_debug(ldb, LDB_DEBUG_ERROR, "Unable to open tdb '%s'\n", path);
+ talloc_free(ltdb);
+ return -1;
}
- ltdb->tdb = tdb;
-
+ ltdb->sequence_number = 0;
- ldb = malloc_p(struct ldb_context);
- if (!ldb) {
- tdb_close(tdb);
- free(ltdb);
- errno = ENOMEM;
- return NULL;
+ *module = talloc(ldb, struct ldb_module);
+ if (!module) {
+ ldb_oom(ldb);
+ talloc_free(ltdb);
+ return -1;
}
+ (*module)->ldb = ldb;
+ (*module)->prev = (*module)->next = NULL;
+ (*module)->private_data = ltdb;
+ (*module)->ops = <db_ops;
- ldb->private = ltdb;
- ldb->ops = <db_ops;
+ return 0;
+}
- return ldb;
+int ldb_tdb_init(void)
+{
+ return ldb_register_backend("tdb", ltdb_connect);
}
git.samba.org / ira / wip.git / blobdiff