s4:ldb Put ltdb_private under the 'module'
[ira/wip.git] / source4 / lib / ldb / ldb_tdb / ldb_tdb.c
index b711efd1fac134267ba4ac7b772bf1815d8a5c27..56c8fa8d702178b5a8c3c3cc2eacae4270dc66ba 100644 (file)
@@ -1,10 +1,10 @@
 /*
    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
  *  - 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 "ldb_includes.h"
-
 #include "ldb_tdb.h"
 
 
@@ -75,41 +81,33 @@ static int ltdb_err_map(enum TDB_ERROR tdb_code)
        return LDB_ERR_OTHER;
 }
 
-
-struct ldb_handle *init_ltdb_handle(struct ltdb_private *ltdb,
-                                   struct ldb_module *module,
-                                   struct ldb_request *req)
+/*
+  lock the database for read - use by ltdb_search and ltdb_sequence_number
+*/
+int ltdb_lock_read(struct ldb_module *module)
 {
-       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;
+       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_context);
-       if (ac == NULL) {
-               ldb_set_errstring(module->ldb, "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 = req->context;
-       ac->callback = req->callback;
-
-       return h;
+       return 0;
 }
 
+
 /*
   form a TDB_DATA for a record key
   caller frees
@@ -119,7 +117,7 @@ struct ldb_handle *init_ltdb_handle(struct ltdb_private *ltdb,
 */
 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;
        const char *dn_folded = NULL;
@@ -167,9 +165,10 @@ failed:
   check special dn's have valid attributes
   currently only @ATTRIBUTES is checked
 */
-int ltdb_check_special_dn(struct ldb_module *module,
+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) ||
@@ -180,9 +179,11 @@ int ltdb_check_special_dn(struct ldb_module *module,
        /* 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++) {
+               if (ldb_attr_cmp(msg->elements[i].name, "distinguishedName") == 0) continue;
+
                for (j = 0; j < msg->elements[i].num_values; j++) {
                        if (ltdb_check_at_attributes_values(&msg->elements[i].values[j]) != 0) {
-                               ldb_set_errstring(module->ldb, "Invalid attribute value in an @ATTRIBUTES entry");
+                               ldb_set_errstring(ldb, "Invalid attribute value in an @ATTRIBUTES entry");
                                return LDB_ERR_INVALID_ATTRIBUTE_SYNTAX;
                        }
                }
@@ -206,12 +207,19 @@ static int ltdb_modified(struct ldb_module *module, struct ldb_dn *dn)
                ret = ltdb_reindex(module);
        }
 
+       /* 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;
 }
 
@@ -220,18 +228,18 @@ static int ltdb_modified(struct ldb_module *module, struct ldb_dn *dn)
 */
 int ltdb_store(struct ldb_module *module, const struct ldb_message *msg, int flgs)
 {
-       struct ltdb_private *ltdb =
-               talloc_get_type(module->private_data, struct ltdb_private);
+       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) {
+       if (tdb_key.dptr == NULL) {
                return LDB_ERR_OTHER;
        }
 
        ret = ltdb_pack_data(module, msg, &tdb_data);
-       if (ret != LDB_SUCCESS) {
+       if (ret == -1) {
                talloc_free(tdb_key.dptr);
                return LDB_ERR_OTHER;
        }
@@ -258,7 +266,8 @@ done:
 static int ltdb_add_internal(struct ldb_module *module,
                             const struct ldb_message *msg)
 {
-       int ret;
+       struct ldb_context *ldb = ldb_module_get_ctx(module);
+       int ret = LDB_SUCCESS, i;
 
        ret = ltdb_check_special_dn(module, msg);
        if (ret != LDB_SUCCESS) {
@@ -269,62 +278,61 @@ static int ltdb_add_internal(struct ldb_module *module,
                return LDB_ERR_OPERATIONS_ERROR;
        }
 
-       ret = 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 (ret == LDB_ERR_ENTRY_ALREADY_EXISTS) {
-               ldb_asprintf_errstring(module->ldb,
-                                       "Entry %s already exists",
-                                       ldb_dn_get_linearized(msg->dn));
-               return ret;
+               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));
+                       return LDB_ERR_CONSTRAINT_VIOLATION;
+               }
+               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));
+                               return LDB_ERR_CONSTRAINT_VIOLATION;
+                       }
+               }
        }
 
-       if (ret == LDB_SUCCESS) {
-               ret = ltdb_index_one(module, msg, 1);
-               if (ret != LDB_SUCCESS) {
-                       return ret;
+       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));
                }
+               return ret;
+       }
 
-               ret = ltdb_modified(module, msg->dn);
-               if (ret != LDB_SUCCESS) {
-                       return ret;
-               }
+       ret = ltdb_index_one(module, msg, 1);
+       if (ret != LDB_SUCCESS) {
+               return ret;
        }
 
+       ret = ltdb_modified(module, msg->dn);
+
        return ret;
 }
 
 /*
   add a record to the database
 */
-static int ltdb_add(struct ldb_module *module, struct ldb_request *req)
+static int ltdb_add(struct ltdb_context *ctx)
 {
-       struct ltdb_private *ltdb;
-       struct ltdb_context *ltdb_ac;
-       int tret, ret = LDB_SUCCESS;
-
-       ltdb = talloc_get_type(module->private_data, struct ltdb_private);
+       struct ldb_module *module = ctx->module;
+       struct ldb_request *req = ctx->req;
+       int ret = LDB_SUCCESS;
 
-       if (check_critical_controls(req->controls)) {
-               return LDB_ERR_UNSUPPORTED_CRITICAL_EXTENSION;
-       }
+       ldb_request_set_state(req, LDB_ASYNC_PENDING);
 
-       req->handle = init_ltdb_handle(ltdb, module, req);
-       if (req->handle == NULL) {
+       if (ltdb_cache_load(module) != 0) {
                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;
-       }
+       ret = ltdb_add_internal(module, req->op.add.message);
 
-       if (ltdb_ac->callback) {
-               ret = ltdb_ac->callback(module->ldb, ltdb_ac->context, NULL);
-       }
-done:
-       req->handle->state = LDB_ASYNC_DONE;
        return ret;
 }
 
@@ -334,8 +342,8 @@ done:
 */
 int ltdb_delete_noindex(struct ldb_module *module, struct ldb_dn *dn)
 {
-       struct ltdb_private *ltdb =
-               talloc_get_type(module->private_data, struct ltdb_private);
+       void *data = ldb_module_get_private(module);
+       struct ltdb_private *ltdb = talloc_get_type(data, struct ltdb_private);
        TDB_DATA tdb_key;
        int ret;
 
@@ -357,7 +365,7 @@ int ltdb_delete_noindex(struct ldb_module *module, struct ldb_dn *dn)
 static int ltdb_delete_internal(struct ldb_module *module, struct ldb_dn *dn)
 {
        struct ldb_message *msg;
-       int ret;
+       int ret = LDB_SUCCESS;
 
        msg = talloc(module, struct ldb_message);
        if (msg == NULL) {
@@ -402,41 +410,20 @@ done:
 /*
   delete a record from the database
 */
-static int ltdb_delete(struct ldb_module *module, struct ldb_request *req)
+static int ltdb_delete(struct ltdb_context *ctx)
 {
-       struct ltdb_private *ltdb;
-       struct ltdb_context *ltdb_ac;
-       int tret, ret = LDB_SUCCESS;
-
-       ltdb = talloc_get_type(module->private_data, struct ltdb_private);
-
-       if (check_critical_controls(req->controls)) {
-               return LDB_ERR_UNSUPPORTED_CRITICAL_EXTENSION;
-       }
+       struct ldb_module *module = ctx->module;
+       struct ldb_request *req = ctx->req;
+       int ret = LDB_SUCCESS;
 
-       req->handle = NULL;
+       ldb_request_set_state(req, LDB_ASYNC_PENDING);
 
        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;
-       }
+       ret = ltdb_delete_internal(module, req->op.del.dn);
 
-       if (ltdb_ac->callback) {
-               ret = ltdb_ac->callback(module->ldb, ltdb_ac->context, NULL);
-       }
-done:
-       req->handle->state = LDB_ASYNC_DONE;
        return ret;
 }
 
@@ -473,6 +460,11 @@ static int msg_add_element(struct ldb_context *ldb,
        struct ldb_message_element *e2;
        unsigned int i;
 
+       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) {
@@ -486,21 +478,18 @@ static int msg_add_element(struct ldb_context *ldb,
 
        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;
 }
@@ -536,12 +525,17 @@ static int msg_delete_attribute(struct ldb_module *module,
                        msg->num_elements--;
                        i--;
                        msg->elements = talloc_realloc(msg, msg->elements,
-                                                       struct ldb_message_element,
-                                                       msg->num_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;
                }
        }
 
-       return 0;
+       /* Not found */
+       return -1;
 }
 
 /*
@@ -554,7 +548,7 @@ static int msg_delete_element(struct ldb_module *module,
                              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;
@@ -582,10 +576,14 @@ static int msg_delete_element(struct ldb_module *module,
                                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;
 }
 
@@ -600,13 +598,13 @@ static int msg_delete_element(struct ldb_module *module,
 int ltdb_modify_internal(struct ldb_module *module,
                         const struct ldb_message *msg)
 {
-       struct ldb_context *ldb = module->ldb;
-       struct ltdb_private *ltdb =
-               talloc_get_type(module->private_data, struct ltdb_private);
+       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, idx;
+       int ret = LDB_SUCCESS, idx;
 
        tdb_key = ltdb_key(module, msg->dn);
        if (!tdb_key.dptr) {
@@ -621,309 +619,278 @@ int ltdb_modify_internal(struct ldb_module *module,
 
        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);
-       if (ret != LDB_SUCCESS) {
+       free(tdb_data.dptr);
+       if (ret == -1) {
                ret = LDB_ERR_OTHER;
-               goto failed;
+               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;
+               const struct ldb_schema_attribute *a = ldb_schema_attribute_by_name(ldb, el->name);
                const char *dn;
 
-               switch (msg->elements[i].flags & LDB_FLAG_MOD_MASK) {
+               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 */
-                       idx = 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 (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;
                                }
-                               continue;
-                       }
-
-                       el2 = &msg2->elements[idx];
-
-                       /* 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])) {
-                                       ldb_asprintf_errstring(module->ldb, "%s: value #%d already exists", el->name, j);
+                       } 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 failed;
+                                       goto done;
                                }
-                               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;
+
+                               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;
+                                       }
                                }
-                       }
 
-                       vals = talloc_realloc(msg2->elements, el2->values, struct ldb_val,
-                                               el2->num_values + el->num_values);
+                               /* 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;
+                               }
 
-                       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]);
+                               }
 
-                       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;
                        }
 
-                       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, el->name);
+                       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;
+                               }
+                       }
 
-                       for (j=0;j<el->num_values;j++) {
+                       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);
+                                       ldb_asprintf_errstring(ldb, "%s: value #%d provided more than once", el->name, j);
                                        ret = LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS;
-                                       goto failed;
+                                       goto done;
                                }
                        }
 
-                       /* add the replacement element, if not empty */
-                       if (el->num_values != 0 &&
-                           msg_add_element(ldb, msg2, el) != 0) {
+                       /* Delete the attribute if it exists in the DB */
+                       msg_delete_attribute(module, ldb, msg2, el->name);
+
+                       /* Recreate it with the new values */
+                       if (msg_add_element(ldb, msg2, el) != 0) {
                                ret = LDB_ERR_OTHER;
-                               goto failed;
+                               goto done;
                        }
+
                        break;
 
                case LDB_FLAG_MOD_DELETE:
-
                        dn = ldb_dn_get_linearized(msg->dn);
                        if (dn == NULL) {
                                ret = LDB_ERR_OTHER;
-                               goto failed;
+                               goto done;
                        }
 
-                       /* 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) {
-                                       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;
-                               }
-                               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) {
-                                       ldb_asprintf_errstring(module->ldb, "No matching attribute value when deleting attribute: %s on %s", msg->elements[i].name, dn);
+                                       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;
                                }
-                               ret = ltdb_index_del_value(module, dn, &msg->elements[i], j);
-                               if (ret != LDB_SUCCESS) {
-                                       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:
-                       ldb_asprintf_errstring(module->ldb,
+                       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 failed;
+               goto done;
        }
 
        ret = ltdb_modified(module, msg->dn);
        if (ret != LDB_SUCCESS) {
-               goto failed;
+               goto done;
        }
 
+done:
        talloc_free(tdb_key.dptr);
-       free(tdb_data.dptr);
-       return ret;
-
-failed:
-       talloc_free(tdb_key.dptr);
-       free(tdb_data.dptr);
        return ret;
 }
 
 /*
   modify a record
 */
-static int ltdb_modify(struct ldb_module *module, struct ldb_request *req)
+static int ltdb_modify(struct ltdb_context *ctx)
 {
-       struct ltdb_private *ltdb;
-       struct ltdb_context *ltdb_ac;
-       int tret, ret = LDB_SUCCESS;
-
-       ltdb = talloc_get_type(module->private_data, struct ltdb_private);
-
-       if (check_critical_controls(req->controls)) {
-               return LDB_ERR_UNSUPPORTED_CRITICAL_EXTENSION;
-       }
-
-       req->handle = NULL;
+       struct ldb_module *module = ctx->module;
+       struct ldb_request *req = ctx->req;
+       int ret = LDB_SUCCESS;
 
-       req->handle = init_ltdb_handle(ltdb, module, req);
-       if (req->handle == NULL) {
-               return LDB_ERR_OPERATIONS_ERROR;
+       ret = ltdb_check_special_dn(module, req->op.mod.message);
+       if (ret != LDB_SUCCESS) {
+               return ret;
        }
-       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;
-       }
+       ldb_request_set_state(req, LDB_ASYNC_PENDING);
 
        if (ltdb_cache_load(module) != 0) {
-               ret = LDB_ERR_OPERATIONS_ERROR;
-               goto done;
+               return LDB_ERR_OPERATIONS_ERROR;
        }
 
-       tret = ltdb_modify_internal(module, req->op.mod.message);
-       if (tret != LDB_SUCCESS) {
-               req->handle->status = tret;
-               goto done;
-       }
+       ret = ltdb_modify_internal(module, req->op.mod.message);
 
-       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, struct ldb_request *req)
+static int ltdb_rename(struct ltdb_context *ctx)
 {
-       struct ltdb_private *ltdb;
-       struct ltdb_context *ltdb_ac;
+       struct ldb_module *module = ctx->module;
+       struct ldb_request *req = ctx->req;
        struct ldb_message *msg;
-       int tret, ret = LDB_SUCCESS;
-
-       ltdb = talloc_get_type(module->private_data, struct ltdb_private);
-
-       if (check_critical_controls(req->controls)) {
-               return LDB_ERR_UNSUPPORTED_CRITICAL_EXTENSION;
-       }
-
-       req->handle = NULL;
+       int ret = LDB_SUCCESS;
 
-       if (ltdb_cache_load(module) != 0) {
-               return LDB_ERR_OPERATIONS_ERROR;
-       }
+       ldb_request_set_state(req, LDB_ASYNC_PENDING);
 
-       req->handle = init_ltdb_handle(ltdb, module, req);
-       if (req->handle == NULL) {
+       if (ltdb_cache_load(ctx->module) != 0) {
                return LDB_ERR_OPERATIONS_ERROR;
        }
-       ltdb_ac = talloc_get_type(req->handle->private_data, struct ltdb_context);
 
-       msg = talloc(ltdb_ac, struct ldb_message);
+       msg = talloc(ctx, 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, req->op.rename.olddn, msg);
-       if (tret != LDB_SUCCESS) {
+       ret = ltdb_search_dn1(module, req->op.rename.olddn, msg);
+       if (ret != LDB_SUCCESS) {
                /* not finding the old record is an error */
-               req->handle->status = tret;
-               goto done;
+               return ret;
        }
 
        msg->dn = ldb_dn_copy(msg, req->op.rename.newdn);
-       if (!msg->dn) {
-               ret = LDB_ERR_OPERATIONS_ERROR;
-               goto done;
+       if (msg->dn == NULL) {
+               return LDB_ERR_OPERATIONS_ERROR;
        }
 
-       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.
-
-                  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;
-               }
-
-               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;
-               }
-
-               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;
-               }
+       /* 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) {
+               return ret;
        }
 
-       if (ltdb_ac->callback) {
-               ret = ltdb_ac->callback(module->ldb, ltdb_ac->context, NULL);
-       }
-done:
-       req->handle->state = LDB_ASYNC_DONE;
+       ret = ltdb_add_internal(module, msg);
+
        return ret;
 }
 
 static int ltdb_start_trans(struct ldb_module *module)
 {
-       struct ltdb_private *ltdb =
-               talloc_get_type(module->private_data, struct ltdb_private);
+       void *data = ldb_module_get_private(module);
+       struct ltdb_private *ltdb = talloc_get_type(data, struct ltdb_private);
 
        if (tdb_transaction_start(ltdb->tdb) != 0) {
                return ltdb_err_map(tdb_error(ltdb->tdb));
@@ -931,126 +898,391 @@ static int ltdb_start_trans(struct ldb_module *module)
 
        ltdb->in_transaction++;
 
+       ltdb_index_transaction_start(module);
+
        return LDB_SUCCESS;
 }
 
-static int ltdb_end_trans(struct ldb_module *module)
+static int ltdb_prepare_commit(struct ldb_module *module)
 {
-       struct ltdb_private *ltdb =
-               talloc_get_type(module->private_data, struct ltdb_private);
+       void *data = ldb_module_get_private(module);
+       struct ltdb_private *ltdb = talloc_get_type(data, struct ltdb_private);
 
-       ltdb->in_transaction--;
+       if (ltdb->in_transaction != 1) {
+               return LDB_SUCCESS;
+       }
 
-       if (tdb_transaction_commit(ltdb->tdb) != 0) {
+       if (ltdb_index_transaction_commit(module) != 0) {
+               tdb_transaction_cancel(ltdb->tdb);
+               ltdb->in_transaction--;
+               return ltdb_err_map(tdb_error(ltdb->tdb));
+       }
+
+       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_del_trans(struct ldb_module *module)
+static int ltdb_end_trans(struct ldb_module *module)
 {
-       struct ltdb_private *ltdb =
-               talloc_get_type(module->private_data, struct ltdb_private);
+       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_cancel(ltdb->tdb) != 0) {
+       if (tdb_transaction_commit(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)
+static int ltdb_del_trans(struct ldb_module *module)
 {
-       return handle->status;
-}
+       void *data = ldb_module_get_private(module);
+       struct ltdb_private *ltdb = talloc_get_type(data, struct ltdb_private);
 
-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;
+       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));
        }
 
-       /* search, add, modify, delete, rename are handled by their own,
-        * no other op supported */
-       return LDB_ERR_OPERATIONS_ERROR;
+       return LDB_SUCCESS;
 }
 
 /*
   return sequenceNumber from @BASEINFO
 */
-static int ltdb_sequence_number(struct ldb_module *module,
-                               struct ldb_request *req)
+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 tret;
+       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;
+       }
+
+       ldb_request_set_state(req, LDB_ASYNC_PENDING);
 
+       if (ltdb_lock_read(module) != 0) {
+               return LDB_ERR_OPERATIONS_ERROR;
+       }
+
+       res = talloc_zero(req, struct ldb_seqnum_result);
+       if (res == NULL) {
+               ret = LDB_ERR_OPERATIONS_ERROR;
+               goto done;
+       }
        tmp_ctx = talloc_new(req);
        if (tmp_ctx == NULL) {
-               talloc_free(tmp_ctx);
-               return LDB_ERR_OPERATIONS_ERROR;
+               ret = LDB_ERR_OPERATIONS_ERROR;
+               goto done;
        }
 
-       dn = ldb_dn_new(tmp_ctx, module->ldb, LTDB_BASEINFO);
+       dn = ldb_dn_new(tmp_ctx, ldb, LTDB_BASEINFO);
 
        msg = talloc(tmp_ctx, struct ldb_message);
        if (msg == NULL) {
-               talloc_free(tmp_ctx);
-               return LDB_ERR_OPERATIONS_ERROR;
+               ret = LDB_ERR_OPERATIONS_ERROR;
+               goto done;
        }
 
-       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;
+       ret = ltdb_search_dn1(module, dn, msg);
+       if (ret != LDB_SUCCESS) {
+               goto done;
        }
 
-       switch (req->op.seq_num.type) {
+       switch (seq->type) {
        case LDB_SEQ_HIGHEST_SEQ:
-               req->op.seq_num.seq_num = ldb_msg_find_attr_as_uint64(msg, LTDB_SEQUENCE_NUMBER, 0);
+               res->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++;
+               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) {
-                       req->op.seq_num.seq_num = ldb_string_to_time(date);
+                       res->seq_num = ldb_string_to_time(date);
                } else {
-                       req->op.seq_num.seq_num = 0;
+                       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;
+       }
+       (*ext)->oid = LDB_EXTENDED_SEQUENCE_NUMBER;
+       (*ext)->data = talloc_steal(*ext, res);
+
+done:
        talloc_free(tmp_ctx);
+       ltdb_unlock_read(module);
+       return ret;
+}
+
+static void ltdb_request_done(struct ltdb_context *ctx, int error)
+{
+       struct ldb_context *ldb;
+       struct ldb_request *req;
+       struct ldb_reply *ares;
+
+       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;
+       }
+
+       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;
+
+       req->callback(req, ares);
+}
+
+static void ltdb_timeout(struct tevent_context *ev,
+                         struct tevent_timer *te,
+                         struct timeval t,
+                         void *private_data)
+{
+       struct ltdb_context *ctx;
+       ctx = talloc_get_type(private_data, struct ltdb_context);
+
+       if (!ctx->request_terminated) {
+               /* request is done now */
+               ltdb_request_done(ctx, LDB_ERR_TIME_LIMIT_EXCEEDED);
+       }
+
+       if (!ctx->request_terminated) {
+               /* neutralize the spy */
+               ctx->spy->ctx = NULL;
+       }
+       talloc_free(ctx);
+}
+
+static void ltdb_request_extended_done(struct ltdb_context *ctx,
+                                       struct ldb_extended *ext,
+                                       int error)
+{
+       struct ldb_context *ldb;
+       struct ldb_request *req;
+       struct ldb_reply *ares;
+
+       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;
+       }
+
+       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 void ltdb_handle_extended(struct ltdb_context *ctx)
+{
+       struct ldb_extended *ext = NULL;
+       int ret;
+
+       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;
+       }
+
+       ltdb_request_extended_done(ctx, ext, ret);
+}
+
+static void ltdb_callback(struct tevent_context *ev,
+                         struct tevent_timer *te,
+                         struct timeval t,
+                         void *private_data)
+{
+       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_destructor(void *ptr)
+{
+       struct ltdb_req_spy *spy = talloc_get_type(ptr, struct ltdb_req_spy);
+
+       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;
+       }
+
+       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;
+       }
+
+       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;
+       }
+
+       /* 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;
+
+       talloc_set_destructor((TALLOC_CTX *)ac->spy, ltdb_request_destructor);
+
        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,
+       .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,
-       .wait              = ltdb_wait,
-       .sequence_number   = ltdb_sequence_number
 };
 
 /*
@@ -1058,8 +1290,9 @@ static const struct ldb_module_ops ltdb_ops = {
 */
 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)
 {
+       struct ldb_module *module;
        const char *path;
        int tdb_flags, open_flags;
        struct ltdb_private *ltdb;
@@ -1069,7 +1302,7 @@ static int ltdb_connect(struct ldb_context *ldb, const char *url,
                if (strncmp(url, "tdb://", 6) != 0) {
                        ldb_debug(ldb, LDB_DEBUG_ERROR,
                                  "Invalid tdb URL '%s'", url);
-                       return LDB_ERR_OPERATIONS_ERROR;
+                       return -1;
                }
                path = url+6;
        } else {
@@ -1097,41 +1330,38 @@ static int ltdb_connect(struct ldb_context *ldb, const char *url,
        ltdb = talloc_zero(ldb, struct ltdb_private);
        if (!ltdb) {
                ldb_oom(ldb);
-               return LDB_ERR_OPERATIONS_ERROR;
+               return -1;
        }
 
        /* note that we use quite a large default hash size */
        ltdb->tdb = ltdb_wrap_open(ltdb, path, 10000,
                                   tdb_flags, open_flags,
-                                  ldb->create_perms, ldb);
+                                  ldb_get_create_perms(ldb), ldb);
        if (!ltdb->tdb) {
                ldb_debug(ldb, LDB_DEBUG_ERROR,
-                         "Unable to open tdb '%s'\n", path);
+                         "Unable to open tdb '%s'", path);
                talloc_free(ltdb);
-               return LDB_ERR_OPERATIONS_ERROR;
+               return -1;
        }
 
        ltdb->sequence_number = 0;
 
-       *module = talloc(ldb, struct ldb_module);
+       module = ldb_module_new(ldb, ldb, "ldb_tdb backend", &ltdb_ops);
        if (!module) {
-               ldb_oom(ldb);
                talloc_free(ltdb);
-               return LDB_ERR_OPERATIONS_ERROR;
+               return -1;
        }
-       talloc_set_name_const(*module, "ldb_tdb backend");
-       (*module)->ldb = ldb;
-       (*module)->prev = (*module)->next = NULL;
-       (*module)->private_data = ltdb;
-       (*module)->ops = &ltdb_ops;
+       ldb_module_set_private(module, ltdb);
+       talloc_steal(module, ltdb);
 
-       if (ltdb_cache_load(*module) != 0) {
-               talloc_free(*module);
+       if (ltdb_cache_load(module) != 0) {
+               talloc_free(module);
                talloc_free(ltdb);
-               return LDB_ERR_OPERATIONS_ERROR;
+               return -1;
        }
 
-       return LDB_SUCCESS;
+       *_module = module;
+       return 0;
 }
 
 const struct ldb_backend_ops ldb_tdb_backend_ops = {