Copyright (C) Andrew Tridgell 2004
Copyright (C) Stefan Metzmacher 2004
+ Copyright (C) Simo Sorce 2006
** NOTE! The following LGPL license applies to the ldb
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/>.
*/
/*
- * Name: ldb
+ * Name: ldb_tdb
*
* Component: ldb 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/include/ldb.h"
-#include "ldb/include/ldb_errors.h"
-#include "ldb/include/ldb_private.h"
-#include "ldb/ldb_tdb/ldb_tdb.h"
+#include "ldb_includes.h"
-#define LDBLOCK "@INT_LDBLOCK"
+#include "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_handle *init_ltdb_handle(struct ltdb_private *ltdb, struct ldb_module *module,
+ struct ldb_request *req)
+{
+ struct ltdb_context *ac;
+ struct ldb_handle *h;
+
+ h = talloc_zero(req, struct ldb_handle);
+ if (h == NULL) {
+ ldb_set_errstring(module->ldb, "Out of Memory");
+ return NULL;
+ }
+
+ h->module = module;
+
+ ac = talloc_zero(h, struct ltdb_context);
+ if (ac == NULL) {
+ ldb_set_errstring(module->ldb, "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 = req->context;
+ ac->callback = req->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(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;
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
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;
}
- key.dptr = key_str;
+ key.dptr = (uint8_t *)key_str;
key.dsize = strlen(key_str) + 1;
return key;
return key;
}
-/*
- lock the database for write - currently a single lock is used
-*/
-static int ltdb_lock(struct ldb_module *module, const char *lockname)
-{
- struct ltdb_private *ltdb = module->private_data;
- struct ldb_dn *lock_dn;
- char *ldn;
- TDB_DATA key;
- int ret;
-
- if (lockname == NULL) {
- return -1;
- }
-
- ldn = talloc_asprintf(module->ldb, "%s_%s", LDBLOCK, lockname);
- if (ldn == NULL) {
- return -1;
- }
-
- lock_dn = ldb_dn_explode(module->ldb, ldn);
- if (lock_dn == NULL) {
- talloc_free(ldn);
- return -1;
- }
- talloc_free(ldn);
-
- key = ltdb_key(module, lock_dn);
- if (!key.dptr) {
- talloc_free(lock_dn);
- return -1;
- }
-
- ret = tdb_chainlock(ltdb->tdb, key);
-
- talloc_free(key.dptr);
- talloc_free(lock_dn);
-
- return ret;
-}
-
-/*
- unlock the database after a ltdb_lock()
-*/
-static int ltdb_unlock(struct ldb_module *module, const char *lockname)
-{
- struct ltdb_private *ltdb = module->private_data;
- struct ldb_dn *lock_dn;
- char *ldn;
- TDB_DATA key;
-
- if (lockname == NULL) {
- return -1;
- }
-
- ldn = talloc_asprintf(module->ldb, "%s_%s", LDBLOCK, lockname);
- if (ldn == NULL) {
- return -1;
- }
-
- lock_dn = ldb_dn_explode(module->ldb, ldn);
- if (lock_dn == NULL) {
- talloc_free(ldn);
- return -1;
- }
- talloc_free(ldn);
-
- key = ltdb_key(module, lock_dn);
- if (!key.dptr) {
- talloc_free(lock_dn);
- return -1;
- }
-
- tdb_chainunlock(ltdb->tdb, key);
-
- talloc_free(key.dptr);
- talloc_free(lock_dn);
-
- return 0;
-}
-
-
-/*
- lock the database for read - use by ltdb_search
-*/
-int ltdb_lock_read(struct ldb_module *module)
-{
- struct ltdb_private *ltdb = module->private_data;
- TDB_DATA key;
- struct ldb_dn *lock_dn;
- int ret;
-
- lock_dn = ldb_dn_explode(module, LDBLOCK);
- if (lock_dn == NULL) {
- return -1;
- }
-
- key = ltdb_key(module, lock_dn);
- if (!key.dptr) {
- talloc_free(lock_dn);
- return -1;
- }
- talloc_free(lock_dn);
-
- ret = tdb_chainlock_read(ltdb->tdb, key);
- talloc_free(key.dptr);
- return ret;
-}
-
-/*
- unlock the database after a ltdb_lock_read()
-*/
-int ltdb_unlock_read(struct ldb_module *module)
-{
- struct ltdb_private *ltdb = module->private_data;
- struct ldb_dn *lock_dn;
- TDB_DATA key;
-
- lock_dn = ldb_dn_explode(module, LDBLOCK);
- if (lock_dn == NULL) {
- return -1;
- }
-
- key = ltdb_key(module, lock_dn);
- if (!key.dptr) {
- talloc_free(lock_dn);
- return -1;
- }
- talloc_free(lock_dn);
-
- tdb_chainunlock_read(ltdb->tdb, key);
- talloc_free(key.dptr);
- return 0;
-}
-
/*
check special dn's have valid attributes
currently only @ATTRIBUTES is checked
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, err_string);
- }
+ ldb_set_errstring(module->ldb, "Invalid attribute value in an @ATTRIBUTES entry");
return LDB_ERR_INVALID_ATTRIBUTE_SYNTAX;
}
}
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 (ret == LDB_SUCCESS &&
!(ldb_dn_is_special(dn) &&
ldb_dn_check_special(dn, LTDB_BASEINFO)) ) {
ret = ltdb_increase_sequence_number(module);
*/
int ltdb_store(struct ldb_module *module, const struct ldb_message *msg, int flgs)
{
- struct ltdb_private *ltdb = module->private_data;
+ struct ltdb_private *ltdb =
+ talloc_get_type(module->private_data, struct ltdb_private);
TDB_DATA tdb_key, tdb_data;
int ret;
ret = tdb_store(ltdb->tdb, tdb_key, tdb_data, flgs);
if (ret == -1) {
- ret = LDB_ERR_OTHER;
+ 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(struct ldb_module *module, const struct ldb_message *msg)
+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_ERR_SUCCESS) {
+ if (ret != LDB_SUCCESS) {
return ret;
}
- if (ltdb_lock(module, LDBLOCK) != 0) {
- return LDB_ERR_OTHER;
- }
-
if (ltdb_cache_load(module) != 0) {
- ltdb_unlock(module, LDBLOCK);
- return LDB_ERR_OTHER;
+ return LDB_ERR_OPERATIONS_ERROR;
}
ret = ltdb_store(module, msg, TDB_INSERT);
- if (ret == LDB_ERR_SUCCESS) {
- ltdb_modified(module, msg->dn);
+ if (ret == LDB_ERR_ENTRY_ALREADY_EXISTS) {
+ ldb_asprintf_errstring(module->ldb, "Entry %s already exists", ldb_dn_get_linearized(msg->dn));
+ return ret;
+ }
+
+ if (ret == LDB_SUCCESS) {
+ ret = ltdb_index_one(module, msg, 1);
+ if (ret != LDB_SUCCESS) {
+ return ret;
+ }
+
+ ret = ltdb_modified(module, msg->dn);
+ if (ret != LDB_SUCCESS) {
+ return ret;
+ }
}
- ltdb_unlock(module, LDBLOCK);
return ret;
}
+/*
+ add a record to the database
+*/
+static int ltdb_add(struct ldb_module *module, struct ldb_request *req)
+{
+ struct ltdb_private *ltdb = talloc_get_type(module->private_data, struct ltdb_private);
+ struct ltdb_context *ltdb_ac;
+ int tret, ret = LDB_SUCCESS;
+
+ if (check_critical_controls(req->controls)) {
+ return LDB_ERR_UNSUPPORTED_CRITICAL_EXTENSION;
+ }
+
+ req->handle = init_ltdb_handle(ltdb, module, req);
+ if (req->handle == NULL) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+ ltdb_ac = talloc_get_type(req->handle->private_data, struct ltdb_context);
+
+ tret = ltdb_add_internal(module, req->op.add.message);
+ if (tret != LDB_SUCCESS) {
+ req->handle->status = tret;
+ goto done;
+ }
+
+ if (ltdb_ac->callback) {
+ ret = ltdb_ac->callback(module->ldb, ltdb_ac->context, NULL);
+ }
+done:
+ req->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_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;
+ struct ltdb_private *ltdb =
+ talloc_get_type(module->private_data, struct ltdb_private);
TDB_DATA tdb_key;
int ret;
ret = tdb_delete(ltdb->tdb, tdb_key);
talloc_free(tdb_key.dptr);
- if (ret != 0) ret = LDB_ERR_OTHER;
+ 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_module *module, const struct ldb_dn *dn)
+static int ltdb_delete_internal(struct ldb_module *module, struct ldb_dn *dn)
{
- struct ldb_message *msg = NULL;
- int ret = LDB_ERR_OTHER;
-
- if (ltdb_lock(module, LDBLOCK) != 0) {
- return ret;
- }
-
- if (ltdb_cache_load(module) != 0) {
- goto failed;
- }
+ struct ldb_message *msg;
+ int ret;
msg = talloc(module, struct ldb_message);
if (msg == NULL) {
- goto failed;
+ 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(module, dn, msg);
- if (ret != 1) {
+ if (ret != LDB_SUCCESS) {
/* not finding the old record is an error */
- ret = LDB_ERR_NO_SUCH_OBJECT;
- goto failed;
+ goto done;
}
ret = ltdb_delete_noindex(module, dn);
- if (ret != LDB_ERR_SUCCESS) {
- goto failed;
+ 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 */
ret = ltdb_index_del(module, msg);
- if (ret == LDB_ERR_SUCCESS) {
- ltdb_modified(module, dn);
- } else
- ret = LDB_ERR_OTHER;
+ if (ret != LDB_SUCCESS) {
+ goto done;
+ }
- talloc_free(msg);
- ltdb_unlock(module, LDBLOCK);
- return ret;
+ ret = ltdb_modified(module, dn);
+ if (ret != LDB_SUCCESS) {
+ goto done;
+ }
-failed:
+done:
talloc_free(msg);
- ltdb_unlock(module, LDBLOCK);
return ret;
}
+/*
+ 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_context *ltdb_ac;
+ int tret, ret = LDB_SUCCESS;
+
+ if (check_critical_controls(req->controls)) {
+ return LDB_ERR_UNSUPPORTED_CRITICAL_EXTENSION;
+ }
+
+ req->handle = NULL;
+
+ if (ltdb_cache_load(module) != 0) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ req->handle = init_ltdb_handle(ltdb, module, req);
+ if (req->handle == NULL) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+ ltdb_ac = talloc_get_type(req->handle->private_data, struct ltdb_context);
+
+ tret = ltdb_delete_internal(module, req->op.del.dn);
+ if (tret != LDB_SUCCESS) {
+ req->handle->status = tret;
+ goto done;
+ }
+
+ if (ltdb_ac->callback) {
+ ret = ltdb_ac->callback(module->ldb, ltdb_ac->context, NULL);
+ }
+done:
+ req->handle->state = LDB_ASYNC_DONE;
+ return ret;
+}
/*
find an element by attribute name. At the moment this does a linear search, it should
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;
}
}
}
- talloc_free(dn);
return 0;
}
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)));
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 ltdb_private *ltdb =
+ talloc_get_type(module->private_data, struct ltdb_private);
TDB_DATA tdb_key, tdb_data;
struct ldb_message *msg2;
unsigned i, j;
- int ret;
+ int ret, idx;
tdb_key = ltdb_key(module, msg->dn);
if (!tdb_key.dptr) {
tdb_data = tdb_fetch(ltdb->tdb, tdb_key);
if (!tdb_data.dptr) {
talloc_free(tdb_key.dptr);
- return LDB_ERR_OTHER;
+ return ltdb_err_map(tdb_error(ltdb->tdb));
}
msg2 = talloc(tdb_key.dptr, struct ldb_message);
ret = ltdb_unpack_data(module, &tdb_data, msg2);
if (ret == -1) {
- talloc_free(tdb_key.dptr);
- free(tdb_data.dptr);
- return LDB_ERR_OTHER;
+ ret = LDB_ERR_OTHER;
+ goto failed;
}
if (!msg2->dn) {
struct ldb_message_element *el = &msg->elements[i];
struct ldb_message_element *el2;
struct ldb_val *vals;
- char *err_string;
- char *dn;
+ const char *dn;
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);
+ idx = find_element(msg2, el->name);
- if (ret == -1) {
+ if (idx == -1) {
if (msg_add_element(ldb, msg2, el) != 0) {
ret = LDB_ERR_OTHER;
goto failed;
continue;
}
- el2 = &msg2->elements[ret];
+ el2 = &msg2->elements[idx];
- /* An attribute with this name already exists, add all
- * values if they don't already exist. */
+ /* An attribute with this name already exists,
+ * add all values if they don't already exist
+ * (check both the other elements to be added,
+ * and those already in the db). */
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, err_string);
+ ldb_asprintf_errstring(module->ldb, "%s: value #%d already exists", el->name, j);
+ ret = LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS;
+ goto failed;
+ }
+ if (ldb_msg_find_val(el, &el->values[j]) != &el->values[j]) {
+ ldb_asprintf_errstring(module->ldb, "%s: value #%d provided more than once", el->name, j);
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)
+ if (vals == NULL) {
+ ret = LDB_ERR_OTHER;
goto failed;
+ }
for (j=0;j<el->num_values;j++) {
vals[el2->num_values + j] =
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);
+ msg_delete_attribute(module, ldb, msg2, el->name);
+
+ for (j=0;j<el->num_values;j++) {
+ if (ldb_msg_find_val(el, &el->values[j]) != &el->values[j]) {
+ ldb_asprintf_errstring(module->ldb, "%s: value #%d provided more than once", el->name, j);
+ ret = LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS;
+ goto failed;
+ }
+ }
/* add the replacement element, if not empty */
- if (msg->elements[i].num_values != 0 &&
- msg_add_element(ldb, msg2, &msg->elements[i]) != 0) {
+ if (el->num_values != 0 &&
+ msg_add_element(ldb, msg2, el) != 0) {
+ ret = LDB_ERR_OTHER;
goto failed;
}
break;
case LDB_FLAG_MOD_DELETE:
- dn = ldb_dn_linearize(msg2, msg->dn);
- if (dn == NULL) goto failed;
+ dn = ldb_dn_get_linearized(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_strdup(module, "No such attribute");
- if (err_string) ldb_set_errstring(module, err_string);
+ ldb_asprintf_errstring(module->ldb, "No such attribute: %s for delete on %s", msg->elements[i].name, dn);
ret = LDB_ERR_NO_SUCH_ATTRIBUTE;
goto failed;
}
msg2,
msg->elements[i].name,
&msg->elements[i].values[j]) != 0) {
- err_string = talloc_strdup(module, "No such attribute");
- if (err_string) ldb_set_errstring(module, err_string);
+ ldb_asprintf_errstring(module->ldb, "No matching attribute value when deleting attribute: %s on %s", msg->elements[i].name, dn);
ret = LDB_ERR_NO_SUCH_ATTRIBUTE;
goto failed;
}
- if (ltdb_index_del_value(module, dn, &msg->elements[i], j) != 0) {
+ ret = ltdb_index_del_value(module, dn, &msg->elements[i], j);
+ if (ret != LDB_SUCCESS) {
goto failed;
}
}
break;
default:
- err_string = talloc_strdup(module, "Invalid ldb_modify flags");
- if (err_string) ldb_set_errstring(module, err_string);
+ ldb_asprintf_errstring(module->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;
}
/* 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;
+ }
+
+ ret = ltdb_modified(module, msg->dn);
+ if (ret != LDB_SUCCESS) {
+ goto failed;
+ }
talloc_free(tdb_key.dptr);
free(tdb_data.dptr);
/*
modify a record
*/
-static int ltdb_modify(struct ldb_module *module, const struct ldb_message *msg)
+static int ltdb_modify(struct ldb_module *module, struct ldb_request *req)
{
- int ret;
+ struct ltdb_private *ltdb = talloc_get_type(module->private_data, struct ltdb_private);
+ struct ltdb_context *ltdb_ac;
+ int tret, ret = LDB_SUCCESS;
- ret = ltdb_check_special_dn(module, msg);
- if (ret != 0) {
- return ret;
+ if (check_critical_controls(req->controls)) {
+ return LDB_ERR_UNSUPPORTED_CRITICAL_EXTENSION;
}
- if (ltdb_lock(module, LDBLOCK) != 0) {
- return -1;
+ req->handle = NULL;
+
+ req->handle = init_ltdb_handle(ltdb, module, req);
+ if (req->handle == NULL) {
+ return LDB_ERR_OPERATIONS_ERROR;
}
+ ltdb_ac = talloc_get_type(req->handle->private_data, struct ltdb_context);
+ tret = ltdb_check_special_dn(module, req->op.mod.message);
+ if (tret != LDB_SUCCESS) {
+ req->handle->status = tret;
+ goto done;
+ }
+
if (ltdb_cache_load(module) != 0) {
- ltdb_unlock(module, LDBLOCK);
- return -1;
+ ret = LDB_ERR_OPERATIONS_ERROR;
+ goto done;
}
- ret = ltdb_modify_internal(module, msg);
-
- if (ret == LDB_ERR_SUCCESS) {
- ltdb_modified(module, msg->dn);
+ tret = ltdb_modify_internal(module, req->op.mod.message);
+ if (tret != LDB_SUCCESS) {
+ req->handle->status = tret;
+ goto done;
}
- ltdb_unlock(module, LDBLOCK);
-
+ if (ltdb_ac->callback) {
+ ret = ltdb_ac->callback(module->ldb, ltdb_ac->context, NULL);
+ }
+done:
+ req->handle->state = LDB_ASYNC_DONE;
return ret;
}
/*
rename a record
*/
-static int ltdb_rename(struct ldb_module *module, const struct ldb_dn *olddn, const struct ldb_dn *newdn)
+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_context *ltdb_ac;
struct ldb_message *msg;
- char *error_str;
- int ret = LDB_ERR_OTHER;
+ int tret, ret = LDB_SUCCESS;
- if (ltdb_lock(module, LDBLOCK) != 0) {
- return ret;
+ if (check_critical_controls(req->controls)) {
+ return LDB_ERR_UNSUPPORTED_CRITICAL_EXTENSION;
}
+
+ req->handle = NULL;
if (ltdb_cache_load(module) != 0) {
- ltdb_unlock(module, LDBLOCK);
- return ret;
+ return LDB_ERR_OPERATIONS_ERROR;
}
- msg = talloc(module, struct ldb_message);
+ req->handle = init_ltdb_handle(ltdb, module, req);
+ if (req->handle == NULL) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+ ltdb_ac = talloc_get_type(req->handle->private_data, struct ltdb_context);
+
+ msg = talloc(ltdb_ac, struct ldb_message);
if (msg == NULL) {
- goto failed;
+ ret = LDB_ERR_OPERATIONS_ERROR;
+ goto done;
}
/* in case any attribute of the message was indexed, we need
to fetch the old record */
- ret = ltdb_search_dn1(module, olddn, msg);
- if (ret != 1) {
+ tret = ltdb_search_dn1(module, req->op.rename.olddn, msg);
+ if (tret != LDB_SUCCESS) {
/* not finding the old record is an error */
- ret = LDB_ERR_NO_SUCH_OBJECT;
- goto failed;
+ req->handle->status = tret;
+ goto done;
}
- msg->dn = ldb_dn_copy(msg, newdn);
+ msg->dn = ldb_dn_copy(msg, req->op.rename.newdn);
if (!msg->dn) {
- ret = LDB_ERR_OTHER;
- goto failed;
- }
-
- ret = ltdb_add(module, msg);
- if (ret != LDB_ERR_SUCCESS) {
- goto failed;
+ ret = LDB_ERR_OPERATIONS_ERROR;
+ goto done;
}
- ret = ltdb_delete(module, olddn);
- error_str = talloc_strdup(module, ldb_errstring(module->ldb));
- if (ret != LDB_ERR_SUCCESS) {
- ltdb_delete(module, newdn);
- }
+ if (ldb_dn_compare(req->op.rename.olddn, req->op.rename.newdn) == 0) {
+ /* The rename operation is apparently only changing case -
+ the DNs are the same. Delete the old DN before adding
+ the new one to avoid a TDB_ERR_EXISTS error.
- ldb_set_errstring(module, error_str);
+ The only drawback to this is that if the delete
+ succeeds but the add fails, we rely on the
+ transaction to roll this all back. */
+ ret = ltdb_delete_internal(module, req->op.rename.olddn);
+ if (ret != LDB_SUCCESS) {
+ goto done;
+ }
- talloc_free(msg);
- ltdb_unlock(module, LDBLOCK);
+ ret = ltdb_add_internal(module, msg);
+ if (ret != LDB_SUCCESS) {
+ goto done;
+ }
+ } else {
+ /* The rename operation is changing DNs. Try to add the new
+ DN first to avoid clobbering another DN not related to
+ this rename operation. */
+ ret = ltdb_add_internal(module, msg);
+ if (ret != LDB_SUCCESS) {
+ goto done;
+ }
- return ret;
+ 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;
+ }
+ }
-failed:
- talloc_free(msg);
- ltdb_unlock(module, LDBLOCK);
+ if (ltdb_ac->callback) {
+ ret = ltdb_ac->callback(module->ldb, ltdb_ac->context, NULL);
+ }
+done:
+ req->handle->state = LDB_ASYNC_DONE;
return ret;
}
static int ltdb_start_trans(struct ldb_module *module)
{
- struct ltdb_private *ltdb = module->private_data;
+ struct ltdb_private *ltdb =
+ talloc_get_type(module->private_data, struct ltdb_private);
if (tdb_transaction_start(ltdb->tdb) != 0) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ltdb_err_map(tdb_error(ltdb->tdb));
}
- return LDB_ERR_SUCCESS;
+ return LDB_SUCCESS;
}
-static int ltdb_end_trans(struct ldb_module *module, int status)
+static int ltdb_end_trans(struct ldb_module *module)
{
- struct ltdb_private *ltdb = module->private_data;
+ struct ltdb_private *ltdb =
+ talloc_get_type(module->private_data, struct ltdb_private);
- if (status != LDB_ERR_SUCCESS) {
- if (tdb_transaction_cancel(ltdb->tdb) != 0) {
- return LDB_ERR_OPERATIONS_ERROR;
- }
- } else {
- if (tdb_transaction_commit(ltdb->tdb) != 0) {
- return LDB_ERR_OPERATIONS_ERROR;
- }
+ 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 =
+ talloc_get_type(module->private_data, struct ltdb_private);
+
+ if (tdb_transaction_cancel(ltdb->tdb) != 0) {
+ return ltdb_err_map(tdb_error(ltdb->tdb));
+ }
+
+ return LDB_SUCCESS;
+}
+
+static int ltdb_wait(struct ldb_handle *handle, enum ldb_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 (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_new(tmp_ctx, module->ldb, LTDB_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;
}
- return status;
+ req->op.seq_num.flags = 0;
+
+ tret = ltdb_search_dn1(module, dn, msg);
+ if (tret != LDB_SUCCESS) {
+ talloc_free(tmp_ctx);
+ /* zero is as good as anything when we don't know */
+ req->op.seq_num.seq_num = 0;
+ return LDB_SUCCESS;
+ }
+
+ switch (req->op.seq_num.type) {
+ case LDB_SEQ_HIGHEST_SEQ:
+ req->op.seq_num.seq_num = ldb_msg_find_attr_as_uint64(msg, LTDB_SEQUENCE_NUMBER, 0);
+ break;
+ case LDB_SEQ_NEXT:
+ req->op.seq_num.seq_num = ldb_msg_find_attr_as_uint64(msg, LTDB_SEQUENCE_NUMBER, 0);
+ req->op.seq_num.seq_num++;
+ break;
+ case LDB_SEQ_HIGHEST_TIMESTAMP:
+ {
+ const char *date = ldb_msg_find_attr_as_string(msg, LTDB_MOD_TIMESTAMP, NULL);
+ if (date) {
+ req->op.seq_num.seq_num = ldb_string_to_time(date);
+ } else {
+ req->op.seq_num.seq_num = 0;
+ /* zero is as good as anything when we don't know */
+ }
+ break;
+ }
+ }
+ talloc_free(tmp_ctx);
+ return LDB_SUCCESS;
}
static const struct ldb_module_ops ltdb_ops = {
.name = "tdb",
.search = ltdb_search,
- .search_bytree = ltdb_search_bytree,
- .add_record = ltdb_add,
- .modify_record = ltdb_modify,
- .delete_record = ltdb_delete,
- .rename_record = ltdb_rename,
+ .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
+ .end_transaction = ltdb_end_trans,
+ .del_transaction = ltdb_del_trans,
+ .wait = ltdb_wait,
+ .sequence_number = ltdb_sequence_number
};
-
/*
connect to the database
*/
-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)
{
const char *path;
int tdb_flags, open_flags;
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->create_perms, ldb);
if (!ltdb->tdb) {
ldb_debug(ldb, LDB_DEBUG_ERROR, "Unable to open tdb '%s'\n", path);
talloc_free(ltdb);
ltdb->sequence_number = 0;
- ldb->modules = talloc(ldb, struct ldb_module);
- if (!ldb->modules) {
+ *module = talloc(ldb, struct ldb_module);
+ if (!module) {
ldb_oom(ldb);
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;
+ talloc_set_name_const(*module, "ldb_tdb backend");
+ (*module)->ldb = ldb;
+ (*module)->prev = (*module)->next = NULL;
+ (*module)->private_data = ltdb;
+ (*module)->ops = <db_ops;
+
+ if (ltdb_cache_load(*module) != 0) {
+ talloc_free(*module);
+ talloc_free(ltdb);
+ return -1;
+ }
return 0;
}
+
+int ldb_tdb_init(void)
+{
+ return ldb_register_backend("tdb", ltdb_connect);
+}
git.samba.org / kai / samba.git / blobdiff