r19402: - use the new tdb_lockall_read() to make ldb_search() more efficient,

[jra/samba/.git] / source4 / lib / ldb / ldb_tdb / ldb_tdb.c

diff --git a/source4/lib/ldb/ldb_tdb/ldb_tdb.c b/source4/lib/ldb/ldb_tdb/ldb_tdb.c
index 1401052955a3b6a2272e0e8a7c8d2cf87ea754da..3f9db3909734d119ce9595f56cbc44c0d49a23a2 100644 (file)
--- a/source4/lib/ldb/ldb_tdb/ldb_tdb.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_tdb.c
@@ -79,15 +79,14 @@ static int ltdb_err_map(enum TDB_ERROR tdb_code)
 
 
 struct ldb_handle *init_ltdb_handle(struct ltdb_private *ltdb, struct ldb_module *module,
-                                         void *context,
-                                         int (*callback)(struct ldb_context *, void *, struct ldb_reply *))
+                                   struct ldb_request *req)
 {
        struct ltdb_context *ac;
        struct ldb_handle *h;
 
-       h = talloc_zero(ltdb, struct ldb_handle);
+       h = talloc_zero(req, struct ldb_handle);
        if (h == NULL) {
-               ldb_set_errstring(module->ldb, talloc_asprintf(module, "Out of Memory"));
+               ldb_set_errstring(module->ldb, "Out of Memory");
                return NULL;
        }
 
@@ -95,7 +94,7 @@ struct ldb_handle *init_ltdb_handle(struct ltdb_private *ltdb, struct ldb_module
 
        ac = talloc_zero(h, struct ltdb_context);
        if (ac == NULL) {
-               ldb_set_errstring(module->ldb, talloc_asprintf(module, "Out of Memory"));
+               ldb_set_errstring(module->ldb, "Out of Memory");
                talloc_free(h);
                return NULL;
        }
@@ -106,8 +105,8 @@ struct ldb_handle *init_ltdb_handle(struct ltdb_private *ltdb, struct ldb_module
        h->status = LDB_SUCCESS;
 
        ac->module = module;
-       ac->context = context;
-       ac->callback = callback;
+       ac->context = req->context;
+       ac->callback = req->callback;
 
        return h;
 }
@@ -138,7 +137,7 @@ struct TDB_DATA ltdb_key(struct ldb_module *module, const struct ldb_dn *dn)
             the rest
        */
 
-       dn_folded = ldb_dn_linearize_casefold(ldb, dn);
+       dn_folded = ldb_dn_linearize_casefold(ldb, ldb, dn);
        if (!dn_folded) {
                goto failed;
        }
@@ -181,10 +180,7 @@ int ltdb_check_special_dn(struct ldb_module *module, const struct ldb_message *m
        for (i = 0; i < msg->num_elements; i++) {
                for (j = 0; j < msg->elements[i].num_values; j++) {
                        if (ltdb_check_at_attributes_values(&msg->elements[i].values[j]) != 0) {
-                               char *err_string = talloc_strdup(module, "Invalid attribute value in an @ATTRIBUTES entry");
-                               if (err_string) {
-                                       ldb_set_errstring(module->ldb, err_string);
-                               }
+                               ldb_set_errstring(module->ldb, "Invalid attribute value in an @ATTRIBUTES entry");
                                return LDB_ERR_INVALID_ATTRIBUTE_SYNTAX;
                        }
                }
@@ -222,7 +218,8 @@ static int ltdb_modified(struct ldb_module *module, const struct ldb_dn *dn)
 */
 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;
 
@@ -270,16 +267,27 @@ static int ltdb_add_internal(struct ldb_module *module, const struct ldb_message
        }
 
        ret = ltdb_store(module, msg, TDB_INSERT);
-       if (ret != LDB_SUCCESS) {
+
+       if (ret == LDB_ERR_ENTRY_ALREADY_EXISTS) {
+               char *dn;
+
+               dn = ldb_dn_linearize(module, msg->dn);
+               if (!dn) {
+                       return ret;
+               }
+               ldb_asprintf_errstring(module->ldb, "Entry %s already exists", dn);
+               talloc_free(dn);
                return ret;
        }
-
-       ret = ltdb_modified(module, msg->dn);
-       if (ret != LDB_SUCCESS) {
-               return LDB_ERR_OPERATIONS_ERROR;
+       
+       if (ret == LDB_SUCCESS) {
+               ret = ltdb_modified(module, msg->dn);
+               if (ret != LDB_SUCCESS) {
+                       return LDB_ERR_OPERATIONS_ERROR;
+               }
        }
 
-       return LDB_SUCCESS;
+       return ret;
 }
 
 /*
@@ -298,7 +306,7 @@ static int ltdb_add(struct ldb_module *module, struct ldb_request *req)
                }
        }
        
-       req->handle = init_ltdb_handle(ltdb, module, req->context, req->callback);
+       req->handle = init_ltdb_handle(ltdb, module, req);
        if (req->handle == NULL) {
                return LDB_ERR_OPERATIONS_ERROR;
        }
@@ -324,7 +332,8 @@ done:
 */
 int ltdb_delete_noindex(struct ldb_module *module, const 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;
 
@@ -377,6 +386,7 @@ static int ltdb_delete_internal(struct ldb_module *module, const struct ldb_dn *
 
        ret = ltdb_modified(module, dn);
        if (ret != LDB_SUCCESS) {
+               talloc_free(msg);
                return LDB_ERR_OPERATIONS_ERROR;
        }
 
@@ -406,7 +416,7 @@ static int ltdb_delete(struct ldb_module *module, struct ldb_request *req)
                return LDB_ERR_OPERATIONS_ERROR;
        }
 
-       req->handle = init_ltdb_handle(ltdb, module, req->context, req->callback);
+       req->handle = init_ltdb_handle(ltdb, module, req);
        if (req->handle == NULL) {
                return LDB_ERR_OPERATIONS_ERROR;
        }
@@ -581,7 +591,8 @@ 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 = 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;
@@ -618,7 +629,6 @@ int ltdb_modify_internal(struct ldb_module *module, const struct ldb_message *ms
                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) {
@@ -643,8 +653,7 @@ int ltdb_modify_internal(struct ldb_module *module, const struct ldb_message *ms
 
                        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);
+                                       ldb_set_errstring(module->ldb, "Type or value exists");
                                        ret = LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS;
                                        goto failed;
                                }
@@ -694,8 +703,7 @@ int ltdb_modify_internal(struct ldb_module *module, const struct ldb_message *ms
                        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);
+                                       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;
                                }
@@ -706,8 +714,7 @@ int ltdb_modify_internal(struct ldb_module *module, const struct ldb_message *ms
                                                       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);
+                                       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;
                                }
@@ -718,10 +725,9 @@ int ltdb_modify_internal(struct ldb_module *module, const struct ldb_message *ms
                        }
                        break;
                default:
-                       err_string = talloc_asprintf(module, "Invalid ldb_modify flags on %s: 0x%x", 
-                                                    msg->elements[i].name, 
-                                                    msg->elements[i].flags & LDB_FLAG_MOD_MASK);
-                       if (err_string) ldb_set_errstring(module->ldb, err_string);
+                       ldb_asprintf_errstring(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;
                }
@@ -766,7 +772,7 @@ static int ltdb_modify(struct ldb_module *module, struct ldb_request *req)
        
        req->handle = NULL;
 
-       req->handle = init_ltdb_handle(ltdb, module, req->context, req->callback);
+       req->handle = init_ltdb_handle(ltdb, module, req);
        if (req->handle == NULL) {
                return LDB_ERR_OPERATIONS_ERROR;
        }
@@ -820,7 +826,7 @@ static int ltdb_rename(struct ldb_module *module, struct ldb_request *req)
                return LDB_ERR_OPERATIONS_ERROR;
        }
 
-       req->handle = init_ltdb_handle(ltdb, module, req->context, req->callback);
+       req->handle = init_ltdb_handle(ltdb, module, req);
        if (req->handle == NULL) {
                return LDB_ERR_OPERATIONS_ERROR;
        }
@@ -870,7 +876,8 @@ done:
 
 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 ltdb_err_map(tdb_error(ltdb->tdb));
@@ -881,7 +888,8 @@ static int ltdb_start_trans(struct ldb_module *module)
 
 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 (tdb_transaction_commit(ltdb->tdb) != 0) {
                return ltdb_err_map(tdb_error(ltdb->tdb));
@@ -892,7 +900,8 @@ static int ltdb_end_trans(struct ldb_module *module)
 
 static int ltdb_del_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_cancel(ltdb->tdb) != 0) {
                return ltdb_err_map(tdb_error(ltdb->tdb));
@@ -941,6 +950,8 @@ static int ltdb_sequence_number(struct ldb_module *module, struct ldb_request *r
                return LDB_ERR_OPERATIONS_ERROR;
        }
 
+       req->op.seq_num.flags = 0;
+
        tret = ltdb_search_dn1(module, dn, msg);
        if (tret != 1) {
                talloc_free(tmp_ctx);
@@ -949,7 +960,26 @@ static int ltdb_sequence_number(struct ldb_module *module, struct ldb_request *r
                return LDB_SUCCESS;
        }
 
-       req->op.seq_num.seq_num = ldb_msg_find_uint64(msg, LTDB_SEQUENCE_NUMBER, 0);
+       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;
 }
@@ -991,7 +1021,7 @@ static int ltdb_connect(struct ldb_context *ldb, const char *url,
                path = url;
        }
 
-       tdb_flags = TDB_DEFAULT;
+       tdb_flags = TDB_DEFAULT | TDB_SEQNUM;
 
        /* check for the 'nosync' option */
        if (flags & LDB_FLG_NOSYNC) {
@@ -1012,7 +1042,8 @@ static int ltdb_connect(struct ldb_context *ldb, const char *url,
 
        /* note that we use quite a large default hash size */
        ltdb->tdb = ltdb_wrap_open(ltdb, path, 10000, 
-                                  tdb_flags, open_flags, 0666, ldb);
+                                  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);
@@ -1027,11 +1058,18 @@ static int ltdb_connect(struct ldb_context *ldb, const char *url,
                talloc_free(ltdb);
                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;
 
+       if (ltdb_cache_load(*module) != 0) {
+               talloc_free(*module);
+               talloc_free(ltdb);
+               return -1;
+       }
+
        return 0;
 }