/*
ldb database library
- Copyright (C) Simo Sorce 2004-2006
+ Copyright (C) Simo Sorce 2004-2008
Copyright (C) Andrew Bartlett <abartlet@samba.org> 2005
Copyright (C) Andrew Tridgell 2005
Copyright (C) Stefan Metzmacher <metze@samba.org> 2007
- ** NOTE! The following LGPL license applies to the ldb
- ** library. This does NOT imply that all of Samba is released
- ** under the LGPL
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 3 of the License, or
+ (at your option) any later version.
- 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 3 of the License, or (at your option) any later version.
-
- This library is distributed in the hope that it will be useful,
+ This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- 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, see <http://www.gnu.org/licenses/>.
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/*
*/
#include "includes.h"
-#include "lib/ldb/include/ldb.h"
-#include "lib/ldb/include/ldb_errors.h"
-#include "lib/ldb/include/ldb_private.h"
+#include "ldb_module.h"
#include "dsdb/samdb/samdb.h"
-#include "dsdb/common/flags.h"
+#include "dsdb/common/proto.h"
+#include "../libds/common/flags.h"
#include "librpc/gen_ndr/ndr_misc.h"
#include "librpc/gen_ndr/ndr_drsuapi.h"
#include "librpc/gen_ndr/ndr_drsblobs.h"
#include "param/param.h"
+#include "libcli/security/dom_sid.h"
+#include "lib/util/dlinklist.h"
+
+struct replmd_private {
+ struct la_entry *la_list;
+};
+
+struct la_entry {
+ struct la_entry *next, *prev;
+ struct drsuapi_DsReplicaLinkedAttribute *la;
+};
struct replmd_replicated_request {
struct ldb_module *module;
- struct ldb_handle *handle;
- struct ldb_request *orig_req;
+ struct ldb_request *req;
const struct dsdb_schema *schema;
uint32_t index_current;
- struct {
- TALLOC_CTX *mem_ctx;
- struct ldb_request *search_req;
- struct ldb_message *search_msg;
- int search_ret;
- struct ldb_request *change_req;
- int change_ret;
- } sub;
+ struct ldb_message *search_msg;
};
-static struct replmd_replicated_request *replmd_replicated_init_handle(struct ldb_module *module,
- struct ldb_request *req,
- struct dsdb_extended_replicated_objects *objs)
+/*
+ created a replmd_replicated_request context
+ */
+static struct replmd_replicated_request *replmd_ctx_init(struct ldb_module *module,
+ struct ldb_request *req)
{
- struct replmd_replicated_request *ar;
- struct ldb_handle *h;
- const struct dsdb_schema *schema;
+ struct ldb_context *ldb;
+ struct replmd_replicated_request *ac;
- schema = dsdb_get_schema(module->ldb);
- if (!schema) {
- ldb_debug_set(module->ldb, LDB_DEBUG_FATAL,
- "replmd_replicated_init_handle: no loaded schema found\n");
- return NULL;
- }
+ ldb = ldb_module_get_ctx(module);
- h = talloc_zero(req, struct ldb_handle);
- if (h == NULL) {
- ldb_set_errstring(module->ldb, "Out of Memory");
+ ac = talloc_zero(req, struct replmd_replicated_request);
+ if (ac == NULL) {
+ ldb_oom(ldb);
return NULL;
}
- h->module = module;
- h->state = LDB_ASYNC_PENDING;
- h->status = LDB_SUCCESS;
-
- ar = talloc_zero(h, struct replmd_replicated_request);
- if (ar == NULL) {
- ldb_set_errstring(module->ldb, "Out of Memory");
- talloc_free(h);
- return NULL;
- }
-
- h->private_data = ar;
-
- ar->module = module;
- ar->handle = h;
- ar->orig_req = req;
- ar->schema = schema;
- ar->objs = objs;
-
- req->handle = h;
-
- return ar;
+ ac->module = module;
+ ac->req = req;
+ return ac;
}
/*
char *s;
if (ldb_msg_find_element(msg, attr) != NULL) {
- return 0;
+ return LDB_SUCCESS;
}
s = ldb_timestring(msg, t);
if (s == NULL) {
- return -1;
+ return LDB_ERR_OPERATIONS_ERROR;
}
- if (ldb_msg_add_string(msg, attr, s) != 0) {
- return -1;
+ if (ldb_msg_add_string(msg, attr, s) != LDB_SUCCESS) {
+ return LDB_ERR_OPERATIONS_ERROR;
}
el = ldb_msg_find_element(msg, attr);
is ignored */
el->flags = LDB_FLAG_MOD_REPLACE;
- return 0;
+ return LDB_SUCCESS;
}
/*
struct ldb_message_element *el;
if (ldb_msg_find_element(msg, attr) != NULL) {
- return 0;
+ return LDB_SUCCESS;
}
- if (ldb_msg_add_fmt(msg, attr, "%llu", (unsigned long long)v) != 0) {
- return -1;
+ if (ldb_msg_add_fmt(msg, attr, "%llu", (unsigned long long)v) != LDB_SUCCESS) {
+ return LDB_ERR_OPERATIONS_ERROR;
}
el = ldb_msg_find_element(msg, attr);
is ignored */
el->flags = LDB_FLAG_MOD_REPLACE;
- return 0;
+ return LDB_SUCCESS;
}
static int replmd_replPropertyMetaData1_attid_sort(const struct replPropertyMetaData1 *m1,
discard_const_p(void, schema), (ldb_qsort_cmp_fn_t)replmd_ldb_message_element_attid_sort);
}
-static int replmd_prepare_originating(struct ldb_module *module, struct ldb_request *req,
- struct ldb_dn *dn, const char *fn_name,
- int (*fn)(struct ldb_module *,
- struct ldb_request *,
- const struct dsdb_schema *))
+static int replmd_op_callback(struct ldb_request *req, struct ldb_reply *ares)
{
- const struct dsdb_schema *schema;
-
- /* do not manipulate our control entries */
- if (ldb_dn_is_special(dn)) {
- return ldb_next_request(module, req);
+ struct ldb_context *ldb;
+ struct replmd_replicated_request *ac;
+
+ ac = talloc_get_type(req->context, struct replmd_replicated_request);
+ ldb = ldb_module_get_ctx(ac->module);
+
+ if (!ares) {
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+ if (ares->error != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, ares->error);
}
- schema = dsdb_get_schema(module->ldb);
- if (!schema) {
- ldb_debug_set(module->ldb, LDB_DEBUG_FATAL,
- "%s: no dsdb_schema loaded",
- fn_name);
- return LDB_ERR_CONSTRAINT_VIOLATION;
+ if (ares->type != LDB_REPLY_DONE) {
+ ldb_set_errstring(ldb,
+ "invalid ldb_reply_type in callback");
+ talloc_free(ares);
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
}
- return fn(module, req, schema);
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, LDB_SUCCESS);
}
-static int replmd_add_originating(struct ldb_module *module,
- struct ldb_request *req,
- const struct dsdb_schema *schema)
+static int replmd_add(struct ldb_module *module, struct ldb_request *req)
{
+ struct ldb_context *ldb;
+ struct replmd_replicated_request *ac;
+ const struct dsdb_schema *schema;
enum ndr_err_code ndr_err;
struct ldb_request *down_req;
struct ldb_message *msg;
int ret;
uint32_t i, ni=0;
- ldb_debug(module->ldb, LDB_DEBUG_TRACE, "replmd_add_originating\n");
+ /* do not manipulate our control entries */
+ if (ldb_dn_is_special(req->op.add.message->dn)) {
+ return ldb_next_request(module, req);
+ }
+
+ ldb = ldb_module_get_ctx(module);
+
+ ldb_debug(ldb, LDB_DEBUG_TRACE, "replmd_add\n");
+
+ schema = dsdb_get_schema(ldb);
+ if (!schema) {
+ ldb_debug_set(ldb, LDB_DEBUG_FATAL,
+ "replmd_add: no dsdb_schema loaded");
+ return LDB_ERR_CONSTRAINT_VIOLATION;
+ }
+
+ ac = replmd_ctx_init(module, req);
+ if (!ac) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
- if (ldb_msg_find_element(req->op.add.message, "objectGUID")) {
- ldb_debug_set(module->ldb, LDB_DEBUG_ERROR,
- "replmd_add_originating: it's not allowed to add an object with objectGUID\n");
+ ac->schema = schema;
+
+ if (ldb_msg_find_element(req->op.add.message, "objectGUID") != NULL) {
+ ldb_debug_set(ldb, LDB_DEBUG_ERROR,
+ "replmd_add: it's not allowed to add an object with objectGUID\n");
return LDB_ERR_UNWILLING_TO_PERFORM;
}
/* Get a sequence number from the backend */
- ret = ldb_sequence_number(module->ldb, LDB_SEQ_NEXT, &seq_num);
+ ret = ldb_sequence_number(ldb, LDB_SEQ_NEXT, &seq_num);
if (ret != LDB_SUCCESS) {
return ret;
}
/* a new GUID */
guid = GUID_random();
- /* get our invicationId */
- our_invocation_id = samdb_ntds_invocation_id(module->ldb);
+ /* get our invocationId */
+ our_invocation_id = samdb_ntds_invocation_id(ldb);
if (!our_invocation_id) {
- ldb_debug_set(module->ldb, LDB_DEBUG_ERROR,
- "replmd_add_originating: unable to find invocationId\n");
+ ldb_debug_set(ldb, LDB_DEBUG_ERROR,
+ "replmd_add: unable to find invocationId\n");
return LDB_ERR_OPERATIONS_ERROR;
}
- /* create a copy of the request */
- down_req = talloc(req, struct ldb_request);
- if (down_req == NULL) {
- ldb_oom(module->ldb);
- return LDB_ERR_OPERATIONS_ERROR;
- }
- *down_req = *req;
-
/* we have to copy the message as the caller might have it as a const */
- down_req->op.add.message = msg = ldb_msg_copy_shallow(down_req, req->op.add.message);
+ msg = ldb_msg_copy_shallow(ac, req->op.add.message);
if (msg == NULL) {
- talloc_free(down_req);
- ldb_oom(module->ldb);
+ ldb_oom(ldb);
return LDB_ERR_OPERATIONS_ERROR;
}
unix_to_nt_time(&now, t);
time_str = ldb_timestring(msg, t);
if (!time_str) {
- talloc_free(down_req);
return LDB_ERR_OPERATIONS_ERROR;
}
*/
ret = ldb_msg_add_string(msg, "whenCreated", time_str);
if (ret != LDB_SUCCESS) {
- talloc_free(down_req);
- ldb_oom(module->ldb);
+ ldb_oom(ldb);
return LDB_ERR_OPERATIONS_ERROR;
}
struct replPropertyMetaData1,
nmd.ctr.ctr1.count);
if (!nmd.ctr.ctr1.array) {
- talloc_free(down_req);
- ldb_oom(module->ldb);
+ ldb_oom(ldb);
return LDB_ERR_OPERATIONS_ERROR;
}
sa = dsdb_attribute_by_lDAPDisplayName(schema, e->name);
if (!sa) {
- ldb_debug_set(module->ldb, LDB_DEBUG_ERROR,
- "replmd_add_originating: attribute '%s' not defined in schema\n",
+ ldb_debug_set(ldb, LDB_DEBUG_ERROR,
+ "replmd_add: attribute '%s' not defined in schema\n",
e->name);
- talloc_free(down_req);
return LDB_ERR_NO_SUCH_ATTRIBUTE;
}
&guid,
(ndr_push_flags_fn_t)ndr_push_GUID);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
- ldb_oom(module->ldb);
+ ldb_oom(ldb);
return LDB_ERR_OPERATIONS_ERROR;
}
ndr_err = ndr_push_struct_blob(&nmd_value, msg,
- lp_iconv_convenience(ldb_get_opaque(module->ldb, "loadparm")),
+ lp_iconv_convenience(ldb_get_opaque(ldb, "loadparm")),
&nmd,
(ndr_push_flags_fn_t)ndr_push_replPropertyMetaDataBlob);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
- talloc_free(down_req);
- ldb_oom(module->ldb);
+ ldb_oom(ldb);
return LDB_ERR_OPERATIONS_ERROR;
}
*/
ret = ldb_msg_add_value(msg, "objectGUID", &guid_value, NULL);
if (ret != LDB_SUCCESS) {
- talloc_free(down_req);
- ldb_oom(module->ldb);
+ ldb_oom(ldb);
return LDB_ERR_OPERATIONS_ERROR;
}
ret = ldb_msg_add_string(msg, "whenChanged", time_str);
if (ret != LDB_SUCCESS) {
- talloc_free(down_req);
- ldb_oom(module->ldb);
+ ldb_oom(ldb);
return LDB_ERR_OPERATIONS_ERROR;
}
- ret = samdb_msg_add_uint64(module->ldb, msg, msg, "uSNCreated", seq_num);
+ ret = samdb_msg_add_uint64(ldb, msg, msg, "uSNCreated", seq_num);
if (ret != LDB_SUCCESS) {
- talloc_free(down_req);
- ldb_oom(module->ldb);
+ ldb_oom(ldb);
return LDB_ERR_OPERATIONS_ERROR;
}
- ret = samdb_msg_add_uint64(module->ldb, msg, msg, "uSNChanged", seq_num);
+ ret = samdb_msg_add_uint64(ldb, msg, msg, "uSNChanged", seq_num);
if (ret != LDB_SUCCESS) {
- talloc_free(down_req);
- ldb_oom(module->ldb);
+ ldb_oom(ldb);
return LDB_ERR_OPERATIONS_ERROR;
}
ret = ldb_msg_add_value(msg, "replPropertyMetaData", &nmd_value, NULL);
if (ret != LDB_SUCCESS) {
- talloc_free(down_req);
- ldb_oom(module->ldb);
+ ldb_oom(ldb);
return LDB_ERR_OPERATIONS_ERROR;
}
*/
replmd_ldb_message_sort(msg, schema);
- ldb_set_timeout_from_prev_req(module->ldb, req, down_req);
+ ret = ldb_build_add_req(&down_req, ldb, ac,
+ msg,
+ req->controls,
+ ac, replmd_op_callback,
+ req);
+ if (ret != LDB_SUCCESS) {
+ return ret;
+ }
/* go on with the call chain */
- ret = ldb_next_request(module, down_req);
+ return ldb_next_request(module, down_req);
+}
- /* do not free down_req as the call results may be linked to it,
- * it will be freed when the upper level request get freed */
- if (ret == LDB_SUCCESS) {
- req->handle = down_req->handle;
+
+/*
+ * update the replPropertyMetaData for one element
+ */
+static int replmd_update_rpmd_element(struct ldb_context *ldb,
+ struct ldb_message *msg,
+ struct ldb_message_element *el,
+ struct replPropertyMetaDataBlob *omd,
+ struct dsdb_schema *schema,
+ uint64_t *seq_num,
+ const struct GUID *our_invocation_id,
+ NTTIME now)
+{
+ int i;
+ const struct dsdb_attribute *a;
+ struct replPropertyMetaData1 *md1;
+
+ a = dsdb_attribute_by_lDAPDisplayName(schema, el->name);
+ if (a == NULL) {
+ DEBUG(0,(__location__ ": Unable to find attribute %s in schema\n",
+ el->name));
+ return LDB_ERR_OPERATIONS_ERROR;
}
- return ret;
+ if ((a->systemFlags & 0x00000001) || (a->systemFlags & 0x00000004)) {
+ /* if the attribute is not replicated (0x00000001)
+ * or constructed (0x00000004) it has no metadata
+ */
+ return LDB_SUCCESS;
+ }
+
+ for (i=0; i<omd->ctr.ctr1.count; i++) {
+ if (a->attributeID_id == omd->ctr.ctr1.array[i].attid) break;
+ }
+ if (i == omd->ctr.ctr1.count) {
+ /* we need to add a new one */
+ omd->ctr.ctr1.array = talloc_realloc(msg, omd->ctr.ctr1.array,
+ struct replPropertyMetaData1, omd->ctr.ctr1.count+1);
+ if (omd->ctr.ctr1.array == NULL) {
+ ldb_oom(ldb);
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+ omd->ctr.ctr1.count++;
+ ZERO_STRUCT(omd->ctr.ctr1.array[i]);
+ }
+
+ /* Get a new sequence number from the backend. We only do this
+ * if we have a change that requires a new
+ * replPropertyMetaData element
+ */
+ if (*seq_num == 0) {
+ int ret = ldb_sequence_number(ldb, LDB_SEQ_NEXT, seq_num);
+ if (ret != LDB_SUCCESS) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+ }
+
+ md1 = &omd->ctr.ctr1.array[i];
+ md1->version++;
+ md1->attid = a->attributeID_id;
+ md1->originating_change_time = now;
+ md1->originating_invocation_id = *our_invocation_id;
+ md1->originating_usn = *seq_num;
+ md1->local_usn = *seq_num;
+
+ return LDB_SUCCESS;
}
-static int replmd_add(struct ldb_module *module, struct ldb_request *req)
+/*
+ * update the replPropertyMetaData object each time we modify an
+ * object. This is needed for DRS replication, as the merge on the
+ * client is based on this object
+ */
+static int replmd_update_rpmd(struct ldb_context *ldb, struct ldb_message *msg,
+ uint64_t *seq_num)
{
- return replmd_prepare_originating(module, req, req->op.add.message->dn,
- "replmd_add", replmd_add_originating);
+ const struct ldb_val *omd_value;
+ enum ndr_err_code ndr_err;
+ struct replPropertyMetaDataBlob omd;
+ int i;
+ struct dsdb_schema *schema;
+ time_t t = time(NULL);
+ NTTIME now;
+ const struct GUID *our_invocation_id;
+ int ret;
+ const char *attrs[] = { "replPropertyMetaData" , NULL };
+ struct ldb_result *res;
+
+ our_invocation_id = samdb_ntds_invocation_id(ldb);
+ if (!our_invocation_id) {
+ /* this happens during an initial vampire while
+ updating the schema */
+ DEBUG(5,("No invocationID - skipping replPropertyMetaData update\n"));
+ return LDB_SUCCESS;
+ }
+
+ unix_to_nt_time(&now, t);
+
+ /* search for the existing replPropertyMetaDataBlob */
+ ret = ldb_search(ldb, msg, &res, msg->dn, LDB_SCOPE_BASE, attrs, NULL);
+ if (ret != LDB_SUCCESS || res->count < 1) {
+ DEBUG(0,(__location__ ": Object %s failed to find replPropertyMetaData\n",
+ ldb_dn_get_linearized(msg->dn)));
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+
+ omd_value = ldb_msg_find_ldb_val(res->msgs[0], "replPropertyMetaData");
+ if (!omd_value) {
+ DEBUG(0,(__location__ ": Object %s does not have a replPropertyMetaData attribute\n",
+ ldb_dn_get_linearized(msg->dn)));
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ ndr_err = ndr_pull_struct_blob(omd_value, msg,
+ lp_iconv_convenience(ldb_get_opaque(ldb, "loadparm")), &omd,
+ (ndr_pull_flags_fn_t)ndr_pull_replPropertyMetaDataBlob);
+ if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+ DEBUG(0,(__location__ ": Failed to parse replPropertyMetaData for %s\n",
+ ldb_dn_get_linearized(msg->dn)));
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ if (omd.version != 1) {
+ DEBUG(0,(__location__ ": bad version %u in replPropertyMetaData for %s\n",
+ omd.version, ldb_dn_get_linearized(msg->dn)));
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ schema = dsdb_get_schema(ldb);
+
+ for (i=0; i<msg->num_elements; i++) {
+ ret = replmd_update_rpmd_element(ldb, msg, &msg->elements[i], &omd, schema, seq_num,
+ our_invocation_id, now);
+ if (ret != LDB_SUCCESS) {
+ return ret;
+ }
+ }
+
+ /*
+ * replmd_update_rpmd_element has done an update if the
+ * seq_num is set
+ */
+ if (*seq_num != 0) {
+ struct ldb_val *md_value;
+ struct ldb_message_element *el;
+
+ md_value = talloc(msg, struct ldb_val);
+ if (md_value == NULL) {
+ ldb_oom(ldb);
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ ndr_err = ndr_push_struct_blob(md_value, msg,
+ lp_iconv_convenience(ldb_get_opaque(ldb, "loadparm")),
+ &omd,
+ (ndr_push_flags_fn_t)ndr_push_replPropertyMetaDataBlob);
+ if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+ DEBUG(0,(__location__ ": Failed to marshall replPropertyMetaData for %s\n",
+ ldb_dn_get_linearized(msg->dn)));
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ ret = ldb_msg_add_empty(msg, "replPropertyMetaData", LDB_FLAG_MOD_REPLACE, &el);
+ if (ret != LDB_SUCCESS) {
+ DEBUG(0,(__location__ ": Failed to add updated replPropertyMetaData %s\n",
+ ldb_dn_get_linearized(msg->dn)));
+ return ret;
+ }
+
+ el->num_values = 1;
+ el->values = md_value;
+ }
+
+ return LDB_SUCCESS;
}
-static int replmd_modify_originating(struct ldb_module *module,
- struct ldb_request *req,
- const struct dsdb_schema *schema)
+
+static int replmd_modify(struct ldb_module *module, struct ldb_request *req)
{
+ struct ldb_context *ldb;
+ struct replmd_replicated_request *ac;
+ const struct dsdb_schema *schema;
struct ldb_request *down_req;
struct ldb_message *msg;
int ret;
time_t t = time(NULL);
- uint64_t seq_num;
+ uint64_t seq_num = 0;
+
+ /* do not manipulate our control entries */
+ if (ldb_dn_is_special(req->op.mod.message->dn)) {
+ return ldb_next_request(module, req);
+ }
- ldb_debug(module->ldb, LDB_DEBUG_TRACE, "replmd_modify_originating\n");
+ ldb = ldb_module_get_ctx(module);
- down_req = talloc(req, struct ldb_request);
- if (down_req == NULL) {
+ ldb_debug(ldb, LDB_DEBUG_TRACE, "replmd_modify\n");
+
+ schema = dsdb_get_schema(ldb);
+ if (!schema) {
+ ldb_debug_set(ldb, LDB_DEBUG_FATAL,
+ "replmd_modify: no dsdb_schema loaded");
+ return LDB_ERR_CONSTRAINT_VIOLATION;
+ }
+
+ ac = replmd_ctx_init(module, req);
+ if (!ac) {
return LDB_ERR_OPERATIONS_ERROR;
}
- *down_req = *req;
+ ac->schema = schema;
/* we have to copy the message as the caller might have it as a const */
- down_req->op.mod.message = msg = ldb_msg_copy_shallow(down_req, req->op.mod.message);
+ msg = ldb_msg_copy_shallow(ac, req->op.mod.message);
if (msg == NULL) {
- talloc_free(down_req);
+ talloc_free(ac);
return LDB_ERR_OPERATIONS_ERROR;
}
* if the caller set values to the same value
* ignore the attribute, return success when no
* attribute was changed
- * - calculate the new replPropertyMetaData attribute
*/
- if (add_time_element(msg, "whenChanged", t) != 0) {
- talloc_free(down_req);
- return LDB_ERR_OPERATIONS_ERROR;
- }
-
- /* Get a sequence number from the backend */
- ret = ldb_sequence_number(module->ldb, LDB_SEQ_NEXT, &seq_num);
- if (ret == LDB_SUCCESS) {
- if (add_uint64_element(msg, "uSNChanged", seq_num) != 0) {
- talloc_free(down_req);
- return LDB_ERR_OPERATIONS_ERROR;
- }
+ ret = replmd_update_rpmd(ldb, msg, &seq_num);
+ if (ret != LDB_SUCCESS) {
+ return ret;
}
/* TODO:
* - replace the old object with the newly constructed one
*/
- ldb_set_timeout_from_prev_req(module->ldb, req, down_req);
-
- /* go on with the call chain */
- ret = ldb_next_request(module, down_req);
-
- /* do not free down_req as the call results may be linked to it,
- * it will be freed when the upper level request get freed */
- if (ret == LDB_SUCCESS) {
- req->handle = down_req->handle;
+ ret = ldb_build_mod_req(&down_req, ldb, ac,
+ msg,
+ req->controls,
+ ac, replmd_op_callback,
+ req);
+ if (ret != LDB_SUCCESS) {
+ return ret;
}
+ talloc_steal(down_req, msg);
- return ret;
-}
-
-static int replmd_modify(struct ldb_module *module, struct ldb_request *req)
-{
- return replmd_prepare_originating(module, req, req->op.mod.message->dn,
- "replmd_modify", replmd_modify_originating);
-}
-
-static int replmd_replicated_request_reply_helper(struct replmd_replicated_request *ar, int ret)
-{
- struct ldb_reply *ares = NULL;
-
- ar->handle->status = ret;
- ar->handle->state = LDB_ASYNC_DONE;
+ /* we only change whenChanged and uSNChanged if the seq_num
+ has changed */
+ if (seq_num != 0) {
+ if (add_time_element(msg, "whenChanged", t) != LDB_SUCCESS) {
+ talloc_free(ac);
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
- if (!ar->orig_req->callback) {
- return LDB_SUCCESS;
- }
-
- /* we're done and need to report the success to the caller */
- ares = talloc_zero(ar, struct ldb_reply);
- if (!ares) {
- ar->handle->status = LDB_ERR_OPERATIONS_ERROR;
- ar->handle->state = LDB_ASYNC_DONE;
- return LDB_ERR_OPERATIONS_ERROR;
+ if (add_uint64_element(msg, "uSNChanged", seq_num) != LDB_SUCCESS) {
+ talloc_free(ac);
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
}
- ares->type = LDB_REPLY_EXTENDED;
- ares->response = NULL;
-
- return ar->orig_req->callback(ar->module->ldb, ar->orig_req->context, ares);
-}
-
-static int replmd_replicated_request_done(struct replmd_replicated_request *ar)
-{
- return replmd_replicated_request_reply_helper(ar, LDB_SUCCESS);
+ /* go on with the call chain */
+ return ldb_next_request(module, down_req);
}
static int replmd_replicated_request_error(struct replmd_replicated_request *ar, int ret)
{
- return replmd_replicated_request_reply_helper(ar, ret);
+ return ret;
}
static int replmd_replicated_request_werror(struct replmd_replicated_request *ar, WERROR status)
{
int ret = LDB_ERR_OTHER;
/* TODO: do some error mapping */
- return replmd_replicated_request_reply_helper(ar, ret);
+ return ret;
}
static int replmd_replicated_apply_next(struct replmd_replicated_request *ar);
-static int replmd_replicated_apply_add_callback(struct ldb_context *ldb,
- void *private_data,
+static int replmd_replicated_apply_add_callback(struct ldb_request *req,
struct ldb_reply *ares)
{
-#ifdef REPLMD_FULL_ASYNC /* TODO: activate this code when ldb support full async code */
- struct replmd_replicated_request *ar = talloc_get_type(private_data,
+ struct ldb_context *ldb;
+ struct replmd_replicated_request *ar = talloc_get_type(req->context,
struct replmd_replicated_request);
+ int ret;
- ar->sub.change_ret = ldb_wait(ar->sub.search_req->handle, LDB_WAIT_ALL);
- if (ar->sub.change_ret != LDB_SUCCESS) {
- return replmd_replicated_request_error(ar, ar->sub.change_ret);
+ ldb = ldb_module_get_ctx(ar->module);
+
+ if (!ares) {
+ return ldb_module_done(ar->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+ if (ares->error != LDB_SUCCESS) {
+ return ldb_module_done(ar->req, ares->controls,
+ ares->response, ares->error);
}
- talloc_free(ar->sub.mem_ctx);
- ZERO_STRUCT(ar->sub);
+ if (ares->type != LDB_REPLY_DONE) {
+ ldb_set_errstring(ldb, "Invalid reply type\n!");
+ return ldb_module_done(ar->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+ talloc_free(ares);
ar->index_current++;
- return replmd_replicated_apply_next(ar);
-#else
+ ret = replmd_replicated_apply_next(ar);
+ if (ret != LDB_SUCCESS) {
+ return ldb_module_done(ar->req, NULL, NULL, ret);
+ }
+
return LDB_SUCCESS;
-#endif
}
static int replmd_replicated_apply_add(struct replmd_replicated_request *ar)
{
+ struct ldb_context *ldb;
+ struct ldb_request *change_req;
enum ndr_err_code ndr_err;
struct ldb_message *msg;
struct replPropertyMetaDataBlob *md;
* same name exist
*/
+ ldb = ldb_module_get_ctx(ar->module);
msg = ar->objs->objects[ar->index_current].msg;
md = ar->objs->objects[ar->index_current].meta_data;
- ret = ldb_sequence_number(ar->module->ldb, LDB_SEQ_NEXT, &seq_num);
+ ret = ldb_sequence_number(ldb, LDB_SEQ_NEXT, &seq_num);
if (ret != LDB_SUCCESS) {
return replmd_replicated_request_error(ar, ret);
}
return replmd_replicated_request_error(ar, ret);
}
- ret = samdb_msg_add_uint64(ar->module->ldb, msg, msg, "uSNCreated", seq_num);
+ ret = samdb_msg_add_uint64(ldb, msg, msg, "uSNCreated", seq_num);
if (ret != LDB_SUCCESS) {
return replmd_replicated_request_error(ar, ret);
}
- ret = samdb_msg_add_uint64(ar->module->ldb, msg, msg, "uSNChanged", seq_num);
+ ret = samdb_msg_add_uint64(ldb, msg, msg, "uSNChanged", seq_num);
if (ret != LDB_SUCCESS) {
return replmd_replicated_request_error(ar, ret);
}
md->ctr.ctr1.array[i].local_usn = seq_num;
}
ndr_err = ndr_push_struct_blob(&md_value, msg,
- lp_iconv_convenience(ldb_get_opaque(ar->module->ldb, "loadparm")),
+ lp_iconv_convenience(ldb_get_opaque(ldb, "loadparm")),
md,
(ndr_push_flags_fn_t)ndr_push_replPropertyMetaDataBlob);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
replmd_ldb_message_sort(msg, ar->schema);
- ret = ldb_build_add_req(&ar->sub.change_req,
- ar->module->ldb,
- ar->sub.mem_ctx,
+ if (DEBUGLVL(4)) {
+ char *s = ldb_ldif_message_string(ldb, ar, LDB_CHANGETYPE_ADD, msg);
+ DEBUG(4, ("DRS replication add message:\n%s\n", s));
+ talloc_free(s);
+ }
+
+ ret = ldb_build_add_req(&change_req,
+ ldb,
+ ar,
msg,
ar->controls,
ar,
- replmd_replicated_apply_add_callback);
+ replmd_replicated_apply_add_callback,
+ ar->req);
if (ret != LDB_SUCCESS) return replmd_replicated_request_error(ar, ret);
-#ifdef REPLMD_FULL_ASYNC /* TODO: activate this code when ldb support full async code */
- return ldb_next_request(ar->module, ar->sub.change_req);
-#else
- ret = ldb_next_request(ar->module, ar->sub.change_req);
- if (ret != LDB_SUCCESS) {
- ldb_asprintf_errstring(ar->module->ldb, "Failed to add replicated object %s: %s", ldb_dn_get_linearized(ar->sub.change_req->op.add.message->dn),
- ldb_errstring(ar->module->ldb));
- return replmd_replicated_request_error(ar, ret);
- }
-
- ar->sub.change_ret = ldb_wait(ar->sub.change_req->handle, LDB_WAIT_ALL);
- if (ar->sub.change_ret != LDB_SUCCESS) {
- ldb_asprintf_errstring(ar->module->ldb, "Failed while waiting on add replicated object %s: %s", ldb_dn_get_linearized(ar->sub.change_req->op.add.message->dn),
- ldb_errstring(ar->module->ldb));
- return replmd_replicated_request_error(ar, ar->sub.change_ret);
- }
-
- talloc_free(ar->sub.mem_ctx);
- ZERO_STRUCT(ar->sub);
-
- ar->index_current++;
-
- return LDB_SUCCESS;
-#endif
+ return ldb_next_request(ar->module, change_req);
}
static int replmd_replPropertyMetaData1_conflict_compare(struct replPropertyMetaData1 *m1,
return m1->originating_usn - m2->originating_usn;
}
-static int replmd_replicated_apply_merge_callback(struct ldb_context *ldb,
- void *private_data,
+static int replmd_replicated_apply_merge_callback(struct ldb_request *req,
struct ldb_reply *ares)
{
-#ifdef REPLMD_FULL_ASYNC /* TODO: activate this code when ldb support full async code */
- struct replmd_replicated_request *ar = talloc_get_type(private_data,
+ struct ldb_context *ldb;
+ struct replmd_replicated_request *ar = talloc_get_type(req->context,
struct replmd_replicated_request);
+ int ret;
- ret = ldb_next_request(ar->module, ar->sub.change_req);
- if (ret != LDB_SUCCESS) return replmd_replicated_request_error(ar, ret);
+ ldb = ldb_module_get_ctx(ar->module);
- ar->sub.change_ret = ldb_wait(ar->sub.search_req->handle, LDB_WAIT_ALL);
- if (ar->sub.change_ret != LDB_SUCCESS) {
- return replmd_replicated_request_error(ar, ar->sub.change_ret);
+ if (!ares) {
+ return ldb_module_done(ar->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+ if (ares->error != LDB_SUCCESS) {
+ return ldb_module_done(ar->req, ares->controls,
+ ares->response, ares->error);
}
- talloc_free(ar->sub.mem_ctx);
- ZERO_STRUCT(ar->sub);
+ if (ares->type != LDB_REPLY_DONE) {
+ ldb_set_errstring(ldb, "Invalid reply type\n!");
+ return ldb_module_done(ar->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+ talloc_free(ares);
ar->index_current++;
+ ret = replmd_replicated_apply_next(ar);
+ if (ret != LDB_SUCCESS) {
+ return ldb_module_done(ar->req, NULL, NULL, ret);
+ }
+
return LDB_SUCCESS;
-#else
- return LDB_SUCCESS;
-#endif
}
static int replmd_replicated_apply_merge(struct replmd_replicated_request *ar)
{
+ struct ldb_context *ldb;
+ struct ldb_request *change_req;
enum ndr_err_code ndr_err;
struct ldb_message *msg;
struct replPropertyMetaDataBlob *rmd;
uint64_t seq_num;
int ret;
+ ldb = ldb_module_get_ctx(ar->module);
msg = ar->objs->objects[ar->index_current].msg;
rmd = ar->objs->objects[ar->index_current].meta_data;
ZERO_STRUCT(omd);
omd.version = 1;
/*
- * TODO: add rename conflict handling
+ * TODO: check repl data is correct after a rename
*/
- if (ldb_dn_compare(msg->dn, ar->sub.search_msg->dn) != 0) {
- ldb_debug_set(ar->module->ldb, LDB_DEBUG_FATAL, "replmd_replicated_apply_merge[%u]: rename not supported",
- ar->index_current);
- ldb_debug(ar->module->ldb, LDB_DEBUG_FATAL, "%s => %s\n",
- ldb_dn_get_linearized(ar->sub.search_msg->dn),
+ if (ldb_dn_compare(msg->dn, ar->search_msg->dn) != 0) {
+ ldb_debug(ldb, LDB_DEBUG_TRACE, "replmd_replicated_request rename %s => %s\n",
+ ldb_dn_get_linearized(ar->search_msg->dn),
ldb_dn_get_linearized(msg->dn));
- return replmd_replicated_request_werror(ar, WERR_NOT_SUPPORTED);
- }
-
- ret = ldb_sequence_number(ar->module->ldb, LDB_SEQ_NEXT, &seq_num);
- if (ret != LDB_SUCCESS) {
- return replmd_replicated_request_error(ar, ret);
+ if (ldb_rename(ldb, ar->search_msg->dn, msg->dn) != LDB_SUCCESS) {
+ ldb_debug(ldb, LDB_DEBUG_FATAL, "replmd_replicated_request rename %s => %s failed - %s\n",
+ ldb_dn_get_linearized(ar->search_msg->dn),
+ ldb_dn_get_linearized(msg->dn),
+ ldb_errstring(ldb));
+ return replmd_replicated_request_werror(ar, WERR_DS_DRA_DB_ERROR);
+ }
}
/* find existing meta data */
- omd_value = ldb_msg_find_ldb_val(ar->sub.search_msg, "replPropertyMetaData");
+ omd_value = ldb_msg_find_ldb_val(ar->search_msg, "replPropertyMetaData");
if (omd_value) {
- ndr_err = ndr_pull_struct_blob(omd_value, ar->sub.mem_ctx,
- lp_iconv_convenience(ldb_get_opaque(ar->module->ldb, "loadparm")), &omd,
+ ndr_err = ndr_pull_struct_blob(omd_value, ar,
+ lp_iconv_convenience(ldb_get_opaque(ldb, "loadparm")), &omd,
(ndr_pull_flags_fn_t)ndr_pull_replPropertyMetaDataBlob);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
NTSTATUS nt_status = ndr_map_error2ntstatus(ndr_err);
ZERO_STRUCT(nmd);
nmd.version = 1;
nmd.ctr.ctr1.count = omd.ctr.ctr1.count + rmd->ctr.ctr1.count;
- nmd.ctr.ctr1.array = talloc_array(ar->sub.mem_ctx,
+ nmd.ctr.ctr1.array = talloc_array(ar,
struct replPropertyMetaData1,
nmd.ctr.ctr1.count);
if (!nmd.ctr.ctr1.array) return replmd_replicated_request_werror(ar, WERR_NOMEM);
for (i=0; i < rmd->ctr.ctr1.count; i++) {
bool found = false;
- rmd->ctr.ctr1.array[i].local_usn = seq_num;
-
for (j=0; j < ni; j++) {
int cmp;
/* create the meta data value */
ndr_err = ndr_push_struct_blob(&nmd_value, msg,
- lp_iconv_convenience(ldb_get_opaque(ar->module->ldb, "loadparm")),
+ lp_iconv_convenience(ldb_get_opaque(ldb, "loadparm")),
&nmd,
(ndr_push_flags_fn_t)ndr_push_replPropertyMetaDataBlob);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
* check if some replicated attributes left, otherwise skip the ldb_modify() call
*/
if (msg->num_elements == 0) {
- ldb_debug(ar->module->ldb, LDB_DEBUG_TRACE, "replmd_replicated_apply_merge[%u]: skip replace\n",
+ ldb_debug(ldb, LDB_DEBUG_TRACE, "replmd_replicated_apply_merge[%u]: skip replace\n",
ar->index_current);
- goto next_object;
+
+ ar->index_current++;
+ return replmd_replicated_apply_next(ar);
}
- ldb_debug(ar->module->ldb, LDB_DEBUG_TRACE, "replmd_replicated_apply_merge[%u]: replace %u attributes\n",
+ ldb_debug(ldb, LDB_DEBUG_TRACE, "replmd_replicated_apply_merge[%u]: replace %u attributes\n",
ar->index_current, msg->num_elements);
+ ret = ldb_sequence_number(ldb, LDB_SEQ_NEXT, &seq_num);
+ if (ret != LDB_SUCCESS) {
+ return replmd_replicated_request_error(ar, ret);
+ }
+
+ for (i=0; i<ni; i++) {
+ nmd.ctr.ctr1.array[i].local_usn = seq_num;
+ }
+
/*
- * when we now that we'll modify the record, add the whenChanged, uSNChanged
+ * when we know that we'll modify the record, add the whenChanged, uSNChanged
* and replPopertyMetaData attributes
*/
ret = ldb_msg_add_string(msg, "whenChanged", ar->objs->objects[ar->index_current].when_changed);
if (ret != LDB_SUCCESS) {
return replmd_replicated_request_error(ar, ret);
}
- ret = samdb_msg_add_uint64(ar->module->ldb, msg, msg, "uSNChanged", seq_num);
+ ret = samdb_msg_add_uint64(ldb, msg, msg, "uSNChanged", seq_num);
if (ret != LDB_SUCCESS) {
return replmd_replicated_request_error(ar, ret);
}
msg->elements[i].flags = LDB_FLAG_MOD_REPLACE;
}
- ret = ldb_build_mod_req(&ar->sub.change_req,
- ar->module->ldb,
- ar->sub.mem_ctx,
+ if (DEBUGLVL(4)) {
+ char *s = ldb_ldif_message_string(ldb, ar, LDB_CHANGETYPE_MODIFY, msg);
+ DEBUG(4, ("DRS replication modify message:\n%s\n", s));
+ talloc_free(s);
+ }
+
+ ret = ldb_build_mod_req(&change_req,
+ ldb,
+ ar,
msg,
ar->controls,
ar,
- replmd_replicated_apply_merge_callback);
- if (ret != LDB_SUCCESS) return replmd_replicated_request_error(ar, ret);
-
-#ifdef REPLMD_FULL_ASYNC /* TODO: activate this code when ldb support full async code */
- return ldb_next_request(ar->module, ar->sub.change_req);
-#else
- ret = ldb_next_request(ar->module, ar->sub.change_req);
+ replmd_replicated_apply_merge_callback,
+ ar->req);
if (ret != LDB_SUCCESS) return replmd_replicated_request_error(ar, ret);
- ar->sub.change_ret = ldb_wait(ar->sub.change_req->handle, LDB_WAIT_ALL);
- if (ar->sub.change_ret != LDB_SUCCESS) {
- return replmd_replicated_request_error(ar, ar->sub.change_ret);
- }
-
-next_object:
- talloc_free(ar->sub.mem_ctx);
- ZERO_STRUCT(ar->sub);
-
- ar->index_current++;
-
- return LDB_SUCCESS;
-#endif
+ return ldb_next_request(ar->module, change_req);
}
-static int replmd_replicated_apply_search_callback(struct ldb_context *ldb,
- void *private_data,
+static int replmd_replicated_apply_search_callback(struct ldb_request *req,
struct ldb_reply *ares)
{
- struct replmd_replicated_request *ar = talloc_get_type(private_data,
+ struct replmd_replicated_request *ar = talloc_get_type(req->context,
struct replmd_replicated_request);
- bool is_done = false;
+ int ret;
+
+ if (!ares) {
+ return ldb_module_done(ar->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+ if (ares->error != LDB_SUCCESS &&
+ ares->error != LDB_ERR_NO_SUCH_OBJECT) {
+ return ldb_module_done(ar->req, ares->controls,
+ ares->response, ares->error);
+ }
switch (ares->type) {
case LDB_REPLY_ENTRY:
- ar->sub.search_msg = talloc_steal(ar->sub.mem_ctx, ares->message);
+ ar->search_msg = talloc_steal(ar, ares->message);
break;
+
case LDB_REPLY_REFERRAL:
/* we ignore referrals */
break;
- case LDB_REPLY_EXTENDED:
- case LDB_REPLY_DONE:
- is_done = true;
- }
- talloc_free(ares);
-
-#ifdef REPLMD_FULL_ASYNC /* TODO: activate this code when ldb support full async code */
- if (is_done) {
- ar->sub.search_ret = ldb_wait(ar->sub.search_req->handle, LDB_WAIT_ALL);
- if (ar->sub.search_ret != LDB_SUCCESS) {
- return replmd_replicated_request_error(ar, ar->sub.search_ret);
+ case LDB_REPLY_DONE:
+ if (ar->search_msg != NULL) {
+ ret = replmd_replicated_apply_merge(ar);
+ } else {
+ ret = replmd_replicated_apply_add(ar);
}
- if (ar->sub.search_msg) {
- return replmd_replicated_apply_merge(ar);
+ if (ret != LDB_SUCCESS) {
+ return ldb_module_done(ar->req, NULL, NULL, ret);
}
- return replmd_replicated_apply_add(ar);
}
-#endif
+
+ talloc_free(ares);
return LDB_SUCCESS;
}
-static int replmd_replicated_apply_search(struct replmd_replicated_request *ar)
+static int replmd_replicated_uptodate_vector(struct replmd_replicated_request *ar);
+
+static int replmd_replicated_apply_next(struct replmd_replicated_request *ar)
{
+ struct ldb_context *ldb;
int ret;
char *tmp_str;
char *filter;
+ struct ldb_request *search_req;
+
+ if (ar->index_current >= ar->objs->num_objects) {
+ /* done with it, go to next stage */
+ return replmd_replicated_uptodate_vector(ar);
+ }
- tmp_str = ldb_binary_encode(ar->sub.mem_ctx, ar->objs->objects[ar->index_current].guid_value);
+ ldb = ldb_module_get_ctx(ar->module);
+ ar->search_msg = NULL;
+
+ tmp_str = ldb_binary_encode(ar, ar->objs->objects[ar->index_current].guid_value);
if (!tmp_str) return replmd_replicated_request_werror(ar, WERR_NOMEM);
- filter = talloc_asprintf(ar->sub.mem_ctx, "(objectGUID=%s)", tmp_str);
+ filter = talloc_asprintf(ar, "(objectGUID=%s)", tmp_str);
if (!filter) return replmd_replicated_request_werror(ar, WERR_NOMEM);
talloc_free(tmp_str);
- ret = ldb_build_search_req(&ar->sub.search_req,
- ar->module->ldb,
- ar->sub.mem_ctx,
+ ret = ldb_build_search_req(&search_req,
+ ldb,
+ ar,
ar->objs->partition_dn,
LDB_SCOPE_SUBTREE,
filter,
NULL,
NULL,
ar,
- replmd_replicated_apply_search_callback);
+ replmd_replicated_apply_search_callback,
+ ar->req);
if (ret != LDB_SUCCESS) return replmd_replicated_request_error(ar, ret);
-#ifdef REPLMD_FULL_ASYNC /* TODO: activate this code when ldb support full async code */
- return ldb_next_request(ar->module, ar->sub.search_req);
-#else
- ret = ldb_next_request(ar->module, ar->sub.search_req);
- if (ret != LDB_SUCCESS) return replmd_replicated_request_error(ar, ret);
-
- ar->sub.search_ret = ldb_wait(ar->sub.search_req->handle, LDB_WAIT_ALL);
- if (ar->sub.search_ret != LDB_SUCCESS && ar->sub.search_ret != LDB_ERR_NO_SUCH_OBJECT) {
- return replmd_replicated_request_error(ar, ar->sub.search_ret);
- }
- if (ar->sub.search_msg) {
- return replmd_replicated_apply_merge(ar);
- }
-
- return replmd_replicated_apply_add(ar);
-#endif
+ return ldb_next_request(ar->module, search_req);
}
-static int replmd_replicated_apply_next(struct replmd_replicated_request *ar)
-{
-#ifdef REPLMD_FULL_ASYNC /* TODO: activate this code when ldb support full async code */
- if (ar->index_current >= ar->objs->num_objects) {
- return replmd_replicated_uptodate_vector(ar);
- }
-#endif
-
- ar->sub.mem_ctx = talloc_new(ar);
- if (!ar->sub.mem_ctx) return replmd_replicated_request_werror(ar, WERR_NOMEM);
-
- return replmd_replicated_apply_search(ar);
-}
-
-static int replmd_replicated_uptodate_modify_callback(struct ldb_context *ldb,
- void *private_data,
+static int replmd_replicated_uptodate_modify_callback(struct ldb_request *req,
struct ldb_reply *ares)
{
-#ifdef REPLMD_FULL_ASYNC /* TODO: activate this code when ldb support full async code */
- struct replmd_replicated_request *ar = talloc_get_type(private_data,
+ struct ldb_context *ldb;
+ struct replmd_replicated_request *ar = talloc_get_type(req->context,
struct replmd_replicated_request);
+ ldb = ldb_module_get_ctx(ar->module);
- ar->sub.change_ret = ldb_wait(ar->sub.search_req->handle, LDB_WAIT_ALL);
- if (ar->sub.change_ret != LDB_SUCCESS) {
- return replmd_replicated_request_error(ar, ar->sub.change_ret);
+ if (!ares) {
+ return ldb_module_done(ar->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+ if (ares->error != LDB_SUCCESS) {
+ return ldb_module_done(ar->req, ares->controls,
+ ares->response, ares->error);
}
- talloc_free(ar->sub.mem_ctx);
- ZERO_STRUCT(ar->sub);
+ if (ares->type != LDB_REPLY_DONE) {
+ ldb_set_errstring(ldb, "Invalid reply type\n!");
+ return ldb_module_done(ar->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
- return replmd_replicated_request_done(ar);
-#else
- return LDB_SUCCESS;
-#endif
+ talloc_free(ares);
+
+ return ldb_module_done(ar->req, NULL, NULL, LDB_SUCCESS);
}
static int replmd_drsuapi_DsReplicaCursor2_compare(const struct drsuapi_DsReplicaCursor2 *c1,
static int replmd_replicated_uptodate_modify(struct replmd_replicated_request *ar)
{
+ struct ldb_context *ldb;
+ struct ldb_request *change_req;
enum ndr_err_code ndr_err;
struct ldb_message *msg;
struct replUpToDateVectorBlob ouv;
struct ldb_val *nrf_value = NULL;
struct ldb_message_element *nrf_el = NULL;
uint32_t i,j,ni=0;
- uint64_t seq_num;
bool found = false;
time_t t = time(NULL);
NTTIME now;
int ret;
+ ldb = ldb_module_get_ctx(ar->module);
ruv = ar->objs->uptodateness_vector;
ZERO_STRUCT(ouv);
ouv.version = 2;
unix_to_nt_time(&now, t);
- /*
- * we use the next sequence number for our own highest_usn
- * because we will do a modify request and this will increment
- * our highest_usn
- */
- ret = ldb_sequence_number(ar->module->ldb, LDB_SEQ_NEXT, &seq_num);
- if (ret != LDB_SUCCESS) {
- return replmd_replicated_request_error(ar, ret);
- }
-
/*
* first create the new replUpToDateVector
*/
- ouv_value = ldb_msg_find_ldb_val(ar->sub.search_msg, "replUpToDateVector");
+ ouv_value = ldb_msg_find_ldb_val(ar->search_msg, "replUpToDateVector");
if (ouv_value) {
- ndr_err = ndr_pull_struct_blob(ouv_value, ar->sub.mem_ctx,
- lp_iconv_convenience(ldb_get_opaque(ar->module->ldb, "loadparm")), &ouv,
+ ndr_err = ndr_pull_struct_blob(ouv_value, ar,
+ lp_iconv_convenience(ldb_get_opaque(ldb, "loadparm")), &ouv,
(ndr_pull_flags_fn_t)ndr_pull_replUpToDateVectorBlob);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
NTSTATUS nt_status = ndr_map_error2ntstatus(ndr_err);
*/
nuv.ctr.ctr2.count = 1 + ouv.ctr.ctr2.count;
if (ruv) nuv.ctr.ctr2.count += ruv->count;
- nuv.ctr.ctr2.cursors = talloc_array(ar->sub.mem_ctx,
+ nuv.ctr.ctr2.cursors = talloc_array(ar,
struct drsuapi_DsReplicaCursor2,
nuv.ctr.ctr2.count);
if (!nuv.ctr.ctr2.cursors) return replmd_replicated_request_werror(ar, WERR_NOMEM);
}
/* get our invocation_id if we have one already attached to the ldb */
- our_invocation_id = samdb_ntds_invocation_id(ar->module->ldb);
+ our_invocation_id = samdb_ntds_invocation_id(ldb);
/* merge in the source_dsa vector is available */
for (i=0; (ruv && i < ruv->count); i++) {
/*
* create the change ldb_message
*/
- msg = ldb_msg_new(ar->sub.mem_ctx);
+ msg = ldb_msg_new(ar);
if (!msg) return replmd_replicated_request_werror(ar, WERR_NOMEM);
- msg->dn = ar->sub.search_msg->dn;
+ msg->dn = ar->search_msg->dn;
ndr_err = ndr_push_struct_blob(&nuv_value, msg,
- lp_iconv_convenience(ldb_get_opaque(ar->module->ldb, "loadparm")),
+ lp_iconv_convenience(ldb_get_opaque(ldb, "loadparm")),
&nuv,
(ndr_push_flags_fn_t)ndr_push_replUpToDateVectorBlob);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
* first see if we already have a repsFrom value for the current source dsa
* if so we'll later replace this value
*/
- orf_el = ldb_msg_find_element(ar->sub.search_msg, "repsFrom");
+ orf_el = ldb_msg_find_element(ar->search_msg, "repsFrom");
if (orf_el) {
for (i=0; i < orf_el->num_values; i++) {
struct repsFromToBlob *trf;
- trf = talloc(ar->sub.mem_ctx, struct repsFromToBlob);
+ trf = talloc(ar, struct repsFromToBlob);
if (!trf) return replmd_replicated_request_werror(ar, WERR_NOMEM);
- ndr_err = ndr_pull_struct_blob(&orf_el->values[i], trf, lp_iconv_convenience(ldb_get_opaque(ar->module->ldb, "loadparm")), trf,
+ ndr_err = ndr_pull_struct_blob(&orf_el->values[i], trf, lp_iconv_convenience(ldb_get_opaque(ldb, "loadparm")), trf,
(ndr_pull_flags_fn_t)ndr_pull_repsFromToBlob);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
NTSTATUS nt_status = ndr_map_error2ntstatus(ndr_err);
/* we now fill the value which is already attached to ldb_message */
ndr_err = ndr_push_struct_blob(nrf_value, msg,
- lp_iconv_convenience(ldb_get_opaque(ar->module->ldb, "loadparm")),
+ lp_iconv_convenience(ldb_get_opaque(ldb, "loadparm")),
&nrf,
(ndr_push_flags_fn_t)ndr_push_repsFromToBlob);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
*/
nrf_el->flags = LDB_FLAG_MOD_REPLACE;
+ if (DEBUGLVL(4)) {
+ char *s = ldb_ldif_message_string(ldb, ar, LDB_CHANGETYPE_MODIFY, msg);
+ DEBUG(4, ("DRS replication uptodate modify message:\n%s\n", s));
+ talloc_free(s);
+ }
+
/* prepare the ldb_modify() request */
- ret = ldb_build_mod_req(&ar->sub.change_req,
- ar->module->ldb,
- ar->sub.mem_ctx,
+ ret = ldb_build_mod_req(&change_req,
+ ldb,
+ ar,
msg,
ar->controls,
ar,
- replmd_replicated_uptodate_modify_callback);
+ replmd_replicated_uptodate_modify_callback,
+ ar->req);
if (ret != LDB_SUCCESS) return replmd_replicated_request_error(ar, ret);
-#ifdef REPLMD_FULL_ASYNC /* TODO: activate this code when ldb support full async code */
- return ldb_next_request(ar->module, ar->sub.change_req);
-#else
- ret = ldb_next_request(ar->module, ar->sub.change_req);
- if (ret != LDB_SUCCESS) return replmd_replicated_request_error(ar, ret);
-
- ar->sub.change_ret = ldb_wait(ar->sub.search_req->handle, LDB_WAIT_ALL);
- if (ar->sub.change_ret != LDB_SUCCESS) {
- return replmd_replicated_request_error(ar, ar->sub.change_ret);
- }
-
- talloc_free(ar->sub.mem_ctx);
- ZERO_STRUCT(ar->sub);
-
- return replmd_replicated_request_done(ar);
-#endif
+ return ldb_next_request(ar->module, change_req);
}
-static int replmd_replicated_uptodate_search_callback(struct ldb_context *ldb,
- void *private_data,
+static int replmd_replicated_uptodate_search_callback(struct ldb_request *req,
struct ldb_reply *ares)
{
- struct replmd_replicated_request *ar = talloc_get_type(private_data,
+ struct replmd_replicated_request *ar = talloc_get_type(req->context,
struct replmd_replicated_request);
- bool is_done = false;
+ int ret;
+
+ if (!ares) {
+ return ldb_module_done(ar->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+ if (ares->error != LDB_SUCCESS &&
+ ares->error != LDB_ERR_NO_SUCH_OBJECT) {
+ return ldb_module_done(ar->req, ares->controls,
+ ares->response, ares->error);
+ }
switch (ares->type) {
case LDB_REPLY_ENTRY:
- ar->sub.search_msg = talloc_steal(ar->sub.mem_ctx, ares->message);
+ ar->search_msg = talloc_steal(ar, ares->message);
break;
+
case LDB_REPLY_REFERRAL:
/* we ignore referrals */
break;
- case LDB_REPLY_EXTENDED:
- case LDB_REPLY_DONE:
- is_done = true;
- }
- talloc_free(ares);
-
-#ifdef REPLMD_FULL_ASYNC /* TODO: activate this code when ldb support full async code */
- if (is_done) {
- ar->sub.search_ret = ldb_wait(ar->sub.search_req->handle, LDB_WAIT_ALL);
- if (ar->sub.search_ret != LDB_SUCCESS) {
- return replmd_replicated_request_error(ar, ar->sub.search_ret);
+ case LDB_REPLY_DONE:
+ if (ar->search_msg == NULL) {
+ ret = replmd_replicated_request_werror(ar, WERR_DS_DRA_INTERNAL_ERROR);
+ } else {
+ ret = replmd_replicated_uptodate_modify(ar);
}
- if (!ar->sub.search_msg) {
- return replmd_replicated_request_werror(ar, WERR_DS_DRA_INTERNAL_ERROR);
+ if (ret != LDB_SUCCESS) {
+ return ldb_module_done(ar->req, NULL, NULL, ret);
}
-
- return replmd_replicated_uptodate_modify(ar);
}
-#endif
+
+ talloc_free(ares);
return LDB_SUCCESS;
}
-static int replmd_replicated_uptodate_search(struct replmd_replicated_request *ar)
+
+static int replmd_replicated_uptodate_vector(struct replmd_replicated_request *ar)
{
+ struct ldb_context *ldb;
int ret;
static const char *attrs[] = {
"replUpToDateVector",
"repsFrom",
NULL
};
+ struct ldb_request *search_req;
+
+ ldb = ldb_module_get_ctx(ar->module);
+ ar->search_msg = NULL;
- ret = ldb_build_search_req(&ar->sub.search_req,
- ar->module->ldb,
- ar->sub.mem_ctx,
+ ret = ldb_build_search_req(&search_req,
+ ldb,
+ ar,
ar->objs->partition_dn,
LDB_SCOPE_BASE,
"(objectClass=*)",
attrs,
NULL,
ar,
- replmd_replicated_uptodate_search_callback);
- if (ret != LDB_SUCCESS) return replmd_replicated_request_error(ar, ret);
-
-#ifdef REPLMD_FULL_ASYNC /* TODO: activate this code when ldb support full async code */
- return ldb_next_request(ar->module, ar->sub.search_req);
-#else
- ret = ldb_next_request(ar->module, ar->sub.search_req);
+ replmd_replicated_uptodate_search_callback,
+ ar->req);
if (ret != LDB_SUCCESS) return replmd_replicated_request_error(ar, ret);
- ar->sub.search_ret = ldb_wait(ar->sub.search_req->handle, LDB_WAIT_ALL);
- if (ar->sub.search_ret != LDB_SUCCESS) {
- return replmd_replicated_request_error(ar, ar->sub.search_ret);
- }
- if (!ar->sub.search_msg) {
- return replmd_replicated_request_werror(ar, WERR_DS_DRA_INTERNAL_ERROR);
- }
-
- return replmd_replicated_uptodate_modify(ar);
-#endif
+ return ldb_next_request(ar->module, search_req);
}
-static int replmd_replicated_uptodate_vector(struct replmd_replicated_request *ar)
-{
- ar->sub.mem_ctx = talloc_new(ar);
- if (!ar->sub.mem_ctx) return replmd_replicated_request_werror(ar, WERR_NOMEM);
- return replmd_replicated_uptodate_search(ar);
-}
static int replmd_extended_replicated_objects(struct ldb_module *module, struct ldb_request *req)
{
+ struct ldb_context *ldb;
struct dsdb_extended_replicated_objects *objs;
struct replmd_replicated_request *ar;
struct ldb_control **ctrls;
- int ret;
+ int ret, i;
+ struct dsdb_control_current_partition *partition_ctrl;
+ struct replmd_private *replmd_private =
+ talloc_get_type(ldb_module_get_private(module), struct replmd_private);
- ldb_debug(module->ldb, LDB_DEBUG_TRACE, "replmd_extended_replicated_objects\n");
+ ldb = ldb_module_get_ctx(module);
+
+ ldb_debug(ldb, LDB_DEBUG_TRACE, "replmd_extended_replicated_objects\n");
objs = talloc_get_type(req->op.extended.data, struct dsdb_extended_replicated_objects);
if (!objs) {
- ldb_debug(module->ldb, LDB_DEBUG_FATAL, "replmd_extended_replicated_objects: invalid extended data\n");
+ ldb_debug(ldb, LDB_DEBUG_FATAL, "replmd_extended_replicated_objects: invalid extended data\n");
return LDB_ERR_PROTOCOL_ERROR;
}
if (objs->version != DSDB_EXTENDED_REPLICATED_OBJECTS_VERSION) {
- ldb_debug(module->ldb, LDB_DEBUG_FATAL, "replmd_extended_replicated_objects: extended data invalid version [%u != %u]\n",
+ ldb_debug(ldb, LDB_DEBUG_FATAL, "replmd_extended_replicated_objects: extended data invalid version [%u != %u]\n",
objs->version, DSDB_EXTENDED_REPLICATED_OBJECTS_VERSION);
return LDB_ERR_PROTOCOL_ERROR;
}
- ar = replmd_replicated_init_handle(module, req, objs);
- if (!ar) {
+ ar = replmd_ctx_init(module, req);
+ if (!ar)
return LDB_ERR_OPERATIONS_ERROR;
+
+ ar->objs = objs;
+ ar->schema = dsdb_get_schema(ldb);
+ if (!ar->schema) {
+ ldb_debug_set(ldb, LDB_DEBUG_FATAL, "replmd_ctx_init: no loaded schema found\n");
+ talloc_free(ar);
+ return LDB_ERR_CONSTRAINT_VIOLATION;
}
ctrls = req->controls;
return ret;
}
+ /*
+ add the DSDB_CONTROL_CURRENT_PARTITION_OID control. This
+ tells the partition module which partition this request is
+ directed at. That is important as the partition roots appear
+ twice in the directory, once as mount points in the top
+ level store, and once as the roots of each partition. The
+ replication code wants to operate on the root of the
+ partitions, not the top level mount points
+ */
+ partition_ctrl = talloc(req, struct dsdb_control_current_partition);
+ if (partition_ctrl == NULL) {
+ if (!partition_ctrl) return replmd_replicated_request_werror(ar, WERR_NOMEM);
+ }
+ partition_ctrl->version = DSDB_CONTROL_CURRENT_PARTITION_VERSION;
+ partition_ctrl->dn = objs->partition_dn;
+
+ ret = ldb_request_add_control(req, DSDB_CONTROL_CURRENT_PARTITION_OID, false, partition_ctrl);
+ if (ret != LDB_SUCCESS) {
+ return ret;
+ }
+
ar->controls = req->controls;
req->controls = ctrls;
-#ifdef REPLMD_FULL_ASYNC /* TODO: activate this code when ldb support full async code */
- return replmd_replicated_apply_next(ar);
-#else
- while (ar->index_current < ar->objs->num_objects &&
- req->handle->state != LDB_ASYNC_DONE) {
- replmd_replicated_apply_next(ar);
- }
+ DEBUG(4,("linked_attributes_count=%u\n", objs->linked_attributes_count));
- if (req->handle->state != LDB_ASYNC_DONE) {
- replmd_replicated_uptodate_vector(ar);
+ /* save away the linked attributes for the end of the
+ transaction */
+ for (i=0; i<ar->objs->linked_attributes_count; i++) {
+ struct la_entry *la_entry;
+
+ if (replmd_private == NULL) {
+ DEBUG(0,(__location__ ": repl_meta_data not called from within a transaction\n"));
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ la_entry = talloc(replmd_private, struct la_entry);
+ if (la_entry == NULL) {
+ ldb_oom(ldb);
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+ la_entry->la = talloc(la_entry, struct drsuapi_DsReplicaLinkedAttribute);
+ if (la_entry->la == NULL) {
+ ldb_oom(ldb);
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+ *la_entry->la = ar->objs->linked_attributes[i];
+
+ /* we need to steal the non-scalars so they stay
+ around until the end of the transaction */
+ talloc_steal(la_entry->la, la_entry->la->identifier);
+ talloc_steal(la_entry->la, la_entry->la->value.blob);
+
+ DLIST_ADD(replmd_private->la_list, la_entry);
}
- return LDB_SUCCESS;
-#endif
+ return replmd_replicated_apply_next(ar);
}
-static int replmd_extended(struct ldb_module *module, struct ldb_request *req)
-{
- if (strcmp(req->op.extended.oid, DSDB_EXTENDED_REPLICATED_OBJECTS_OID) == 0) {
- return replmd_extended_replicated_objects(module, req);
+/*
+ process one linked attribute structure
+ */
+static int replmd_process_linked_attribute(struct ldb_module *module,
+ struct la_entry *la_entry)
+{
+ struct drsuapi_DsReplicaLinkedAttribute *la = la_entry->la;
+ struct ldb_context *ldb = ldb_module_get_ctx(module);
+ struct drsuapi_DsReplicaObjectIdentifier3 target;
+ struct ldb_message *msg;
+ struct ldb_message_element *ret_el;
+ TALLOC_CTX *tmp_ctx = talloc_new(la_entry);
+ enum ndr_err_code ndr_err;
+ char *target_dn;
+ struct ldb_request *mod_req;
+ int ret;
+ const struct dsdb_attribute *attr;
+
+/*
+linked_attributes[0]:
+ &objs->linked_attributes[i]: struct drsuapi_DsReplicaLinkedAttribute
+ identifier : *
+ identifier: struct drsuapi_DsReplicaObjectIdentifier
+ __ndr_size : 0x0000003a (58)
+ __ndr_size_sid : 0x00000000 (0)
+ guid : 8e95b6a9-13dd-4158-89db-3220a5be5cc7
+ sid : S-0-0
+ __ndr_size_dn : 0x00000000 (0)
+ dn : ''
+ attid : DRSUAPI_ATTRIBUTE_member (0x1F)
+ value: struct drsuapi_DsAttributeValue
+ __ndr_size : 0x0000007e (126)
+ blob : *
+ blob : DATA_BLOB length=126
+ flags : 0x00000001 (1)
+ 1: DRSUAPI_DS_LINKED_ATTRIBUTE_FLAG_ACTIVE
+ originating_add_time : Wed Sep 2 22:20:01 2009 EST
+ meta_data: struct drsuapi_DsReplicaMetaData
+ version : 0x00000015 (21)
+ originating_change_time : Wed Sep 2 23:39:07 2009 EST
+ originating_invocation_id: 794640f3-18cf-40ee-a211-a93992b67a64
+ originating_usn : 0x000000000001e19c (123292)
+ &target: struct drsuapi_DsReplicaObjectIdentifier3
+ __ndr_size : 0x0000007e (126)
+ __ndr_size_sid : 0x0000001c (28)
+ guid : 7639e594-db75-4086-b0d4-67890ae46031
+ sid : S-1-5-21-2848215498-2472035911-1947525656-19924
+ __ndr_size_dn : 0x00000022 (34)
+ dn : 'CN=UOne,OU=TestOU,DC=vsofs8,DC=com'
+ */
+ if (DEBUGLVL(4)) {
+ NDR_PRINT_DEBUG(drsuapi_DsReplicaLinkedAttribute, la);
+ }
+
+ /* decode the target of the link */
+ ndr_err = ndr_pull_struct_blob(la->value.blob,
+ tmp_ctx, lp_iconv_convenience(ldb_get_opaque(ldb, "loadparm")),
+ &target,
+ (ndr_pull_flags_fn_t)ndr_pull_drsuapi_DsReplicaObjectIdentifier3);
+ if (ndr_err != NDR_ERR_SUCCESS) {
+ DEBUG(0,("Unable to decode linked_attribute target\n"));
+ dump_data(4, la->value.blob->data, la->value.blob->length);
+ talloc_free(tmp_ctx);
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+ if (DEBUGLVL(4)) {
+ NDR_PRINT_DEBUG(drsuapi_DsReplicaObjectIdentifier3, &target);
}
- return ldb_next_request(module, req);
-}
+ /* construct a modify request for this attribute change */
+ msg = ldb_msg_new(tmp_ctx);
+ if (!msg) {
+ ldb_oom(ldb);
+ talloc_free(tmp_ctx);
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
-static int replmd_wait_none(struct ldb_handle *handle) {
- struct replmd_replicated_request *ar;
-
- if (!handle || !handle->private_data) {
+ ret = dsdb_find_dn_by_guid(ldb, tmp_ctx,
+ GUID_string(tmp_ctx, &la->identifier->guid), &msg->dn);
+ if (ret != LDB_SUCCESS) {
+ talloc_free(tmp_ctx);
+ return ret;
+ }
+
+ /* find the attribute being modified */
+ attr = dsdb_attribute_by_attributeID_id(dsdb_get_schema(ldb), la->attid);
+ if (attr == NULL) {
+ DEBUG(0, (__location__ ": Unable to find attributeID 0x%x\n", la->attid));
+ talloc_free(tmp_ctx);
return LDB_ERR_OPERATIONS_ERROR;
}
- ar = talloc_get_type(handle->private_data, struct replmd_replicated_request);
- if (!ar) {
+ if (la->flags & DRSUAPI_DS_LINKED_ATTRIBUTE_FLAG_ACTIVE) {
+ ret = ldb_msg_add_empty(msg, attr->lDAPDisplayName,
+ LDB_FLAG_MOD_ADD, &ret_el);
+ } else {
+ ret = ldb_msg_add_empty(msg, attr->lDAPDisplayName,
+ LDB_FLAG_MOD_DELETE, &ret_el);
+ }
+ if (ret != LDB_SUCCESS) {
+ talloc_free(tmp_ctx);
+ return ret;
+ }
+ ret_el->values = talloc_array(msg, struct ldb_val, 1);
+ if (!ret_el->values) {
+ ldb_oom(ldb);
+ talloc_free(tmp_ctx);
return LDB_ERR_OPERATIONS_ERROR;
}
+ ret_el->num_values = 1;
- /* we do only sync calls */
- if (handle->state != LDB_ASYNC_DONE) {
+ target_dn = talloc_asprintf(tmp_ctx, "<GUID=%s>;<SID=%s>;%s",
+ GUID_string(tmp_ctx, &target.guid),
+ dom_sid_string(tmp_ctx, &target.sid),
+ target.dn);
+ if (target_dn == NULL) {
+ ldb_oom(ldb);
+ talloc_free(tmp_ctx);
return LDB_ERR_OPERATIONS_ERROR;
}
+ ret_el->values[0] = data_blob_string_const(target_dn);
- return handle->status;
+ ret = ldb_build_mod_req(&mod_req, ldb, tmp_ctx,
+ msg,
+ NULL,
+ NULL,
+ ldb_op_default_callback,
+ NULL);
+ if (ret != LDB_SUCCESS) {
+ talloc_free(tmp_ctx);
+ return ret;
+ }
+ talloc_steal(mod_req, msg);
+
+ if (DEBUGLVL(4)) {
+ DEBUG(4,("Applying DRS linked attribute change:\n%s\n",
+ ldb_ldif_message_string(ldb, tmp_ctx, LDB_CHANGETYPE_MODIFY, msg)));
+ }
+
+ /* Run the new request */
+ ret = ldb_next_request(module, mod_req);
+
+ /* we need to wait for this to finish, as we are being called
+ from the synchronous end_transaction hook of this module */
+ if (ret == LDB_SUCCESS) {
+ ret = ldb_wait(mod_req->handle, LDB_WAIT_ALL);
+ }
+
+ if (ret != LDB_SUCCESS) {
+ ldb_debug(ldb, LDB_DEBUG_WARNING, "Failed to apply linked attribute change '%s' %s\n",
+ ldb_errstring(ldb),
+ ldb_ldif_message_string(ldb, tmp_ctx, LDB_CHANGETYPE_MODIFY, msg));
+ }
+
+ talloc_free(tmp_ctx);
+
+ return ret;
}
-static int replmd_wait_all(struct ldb_handle *handle) {
+static int replmd_extended(struct ldb_module *module, struct ldb_request *req)
+{
+ if (strcmp(req->op.extended.oid, DSDB_EXTENDED_REPLICATED_OBJECTS_OID) == 0) {
+ return replmd_extended_replicated_objects(module, req);
+ }
- int ret;
+ return ldb_next_request(module, req);
+}
+
+
+/*
+ we hook into the transaction operations to allow us to
+ perform the linked attribute updates at the end of the whole
+ transaction. This allows a forward linked attribute to be created
+ before the object is created. During a vampire, w2k8 sends us linked
+ attributes before the objects they are part of.
+ */
+static int replmd_start_transaction(struct ldb_module *module)
+{
+ /* create our private structure for this transaction */
+ struct replmd_private *replmd_private = talloc_get_type(ldb_module_get_private(module),
+ struct replmd_private);
+ talloc_free(replmd_private);
+ replmd_private = talloc(module, struct replmd_private);
+ if (replmd_private == NULL) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+ replmd_private->la_list = NULL;
+ ldb_module_set_private(module, replmd_private);
+ return ldb_next_start_trans(module);
+}
- while (handle->state != LDB_ASYNC_DONE) {
- ret = replmd_wait_none(handle);
+/*
+ on prepare commit we loop over our queued la_context structures and
+ apply each of them
+ */
+static int replmd_prepare_commit(struct ldb_module *module)
+{
+ struct replmd_private *replmd_private =
+ talloc_get_type(ldb_module_get_private(module), struct replmd_private);
+ struct la_entry *la;
+
+ /* walk the list backwards, to do the first entry first, as we
+ * added the entries with DLIST_ADD() which puts them at the
+ * start of the list */
+ for (la = replmd_private->la_list; la && la->next; la=la->next) ;
+
+ for (; la; la=la->prev) {
+ int ret;
+ ret = replmd_process_linked_attribute(module, la);
if (ret != LDB_SUCCESS) {
return ret;
}
}
- return handle->status;
+ talloc_free(replmd_private);
+ ldb_module_set_private(module, NULL);
+
+ return ldb_next_prepare_commit(module);
}
-static int replmd_wait(struct ldb_handle *handle, enum ldb_wait_type type)
+static int replmd_del_transaction(struct ldb_module *module)
{
- if (type == LDB_WAIT_ALL) {
- return replmd_wait_all(handle);
- } else {
- return replmd_wait_none(handle);
- }
+ struct replmd_private *replmd_private =
+ talloc_get_type(ldb_module_get_private(module), struct replmd_private);
+ talloc_free(replmd_private);
+ ldb_module_set_private(module, NULL);
+ return ldb_next_del_trans(module);
}
+
_PUBLIC_ const struct ldb_module_ops ldb_repl_meta_data_module_ops = {
.name = "repl_meta_data",
.add = replmd_add,
.modify = replmd_modify,
.extended = replmd_extended,
- .wait = replmd_wait
+ .start_transaction = replmd_start_transaction,
+ .prepare_commit = replmd_prepare_commit,
+ .del_transaction = replmd_del_transaction,
};
git.samba.org / ira / wip.git / blobdiff