4 Copyright (C) Simo Sorce 2004-2008
5 Copyright (C) Andrew Bartlett <abartlet@samba.org> 2005
6 Copyright (C) Andrew Tridgell 2005
7 Copyright (C) Stefan Metzmacher <metze@samba.org> 2007
9 ** NOTE! The following LGPL license applies to the ldb
10 ** library. This does NOT imply that all of Samba is released
13 This library is free software; you can redistribute it and/or
14 modify it under the terms of the GNU Lesser General Public
15 License as published by the Free Software Foundation; either
16 version 3 of the License, or (at your option) any later version.
18 This library is distributed in the hope that it will be useful,
19 but WITHOUT ANY WARRANTY; without even the implied warranty of
20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
21 Lesser General Public License for more details.
23 You should have received a copy of the GNU Lesser General Public
24 License along with this library; if not, see <http://www.gnu.org/licenses/>.
30 * Component: ldb repl_meta_data module
32 * Description: - add a unique objectGUID onto every new record,
33 * - handle whenCreated, whenChanged timestamps
34 * - handle uSNCreated, uSNChanged numbers
35 * - handle replPropertyMetaData attribute
38 * Author: Stefan Metzmacher
42 #include "ldb_module.h"
43 #include "dsdb/samdb/samdb.h"
44 #include "dsdb/common/flags.h"
45 #include "librpc/gen_ndr/ndr_misc.h"
46 #include "librpc/gen_ndr/ndr_drsuapi.h"
47 #include "librpc/gen_ndr/ndr_drsblobs.h"
48 #include "param/param.h"
50 struct replmd_replicated_request {
51 struct ldb_module *module;
52 struct ldb_request *req;
54 const struct dsdb_schema *schema;
56 struct dsdb_extended_replicated_objects *objs;
58 /* the controls we pass down */
59 struct ldb_control **controls;
61 uint32_t index_current;
63 struct ldb_message *search_msg;
66 static struct replmd_replicated_request *replmd_ctx_init(struct ldb_module *module,
67 struct ldb_request *req)
69 struct ldb_context *ldb;
70 struct replmd_replicated_request *ac;
72 ldb = ldb_module_get_ctx(module);
74 ac = talloc_zero(req, struct replmd_replicated_request);
86 add a time element to a record
88 static int add_time_element(struct ldb_message *msg, const char *attr, time_t t)
90 struct ldb_message_element *el;
93 if (ldb_msg_find_element(msg, attr) != NULL) {
97 s = ldb_timestring(msg, t);
99 return LDB_ERR_OPERATIONS_ERROR;
102 if (ldb_msg_add_string(msg, attr, s) != LDB_SUCCESS) {
103 return LDB_ERR_OPERATIONS_ERROR;
106 el = ldb_msg_find_element(msg, attr);
107 /* always set as replace. This works because on add ops, the flag
109 el->flags = LDB_FLAG_MOD_REPLACE;
115 add a uint64_t element to a record
117 static int add_uint64_element(struct ldb_message *msg, const char *attr, uint64_t v)
119 struct ldb_message_element *el;
121 if (ldb_msg_find_element(msg, attr) != NULL) {
125 if (ldb_msg_add_fmt(msg, attr, "%llu", (unsigned long long)v) != LDB_SUCCESS) {
126 return LDB_ERR_OPERATIONS_ERROR;
129 el = ldb_msg_find_element(msg, attr);
130 /* always set as replace. This works because on add ops, the flag
132 el->flags = LDB_FLAG_MOD_REPLACE;
137 static int replmd_replPropertyMetaData1_attid_sort(const struct replPropertyMetaData1 *m1,
138 const struct replPropertyMetaData1 *m2,
139 const uint32_t *rdn_attid)
141 if (m1->attid == m2->attid) {
146 * the rdn attribute should be at the end!
147 * so we need to return a value greater than zero
148 * which means m1 is greater than m2
150 if (m1->attid == *rdn_attid) {
155 * the rdn attribute should be at the end!
156 * so we need to return a value less than zero
157 * which means m2 is greater than m1
159 if (m2->attid == *rdn_attid) {
163 return m1->attid - m2->attid;
166 static void replmd_replPropertyMetaDataCtr1_sort(struct replPropertyMetaDataCtr1 *ctr1,
167 const uint32_t *rdn_attid)
169 ldb_qsort(ctr1->array, ctr1->count, sizeof(struct replPropertyMetaData1),
170 discard_const_p(void, rdn_attid), (ldb_qsort_cmp_fn_t)replmd_replPropertyMetaData1_attid_sort);
173 static int replmd_ldb_message_element_attid_sort(const struct ldb_message_element *e1,
174 const struct ldb_message_element *e2,
175 const struct dsdb_schema *schema)
177 const struct dsdb_attribute *a1;
178 const struct dsdb_attribute *a2;
181 * TODO: make this faster by caching the dsdb_attribute pointer
182 * on the ldb_messag_element
185 a1 = dsdb_attribute_by_lDAPDisplayName(schema, e1->name);
186 a2 = dsdb_attribute_by_lDAPDisplayName(schema, e2->name);
189 * TODO: remove this check, we should rely on e1 and e2 having valid attribute names
193 return strcasecmp(e1->name, e2->name);
196 return a1->attributeID_id - a2->attributeID_id;
199 static void replmd_ldb_message_sort(struct ldb_message *msg,
200 const struct dsdb_schema *schema)
202 ldb_qsort(msg->elements, msg->num_elements, sizeof(struct ldb_message_element),
203 discard_const_p(void, schema), (ldb_qsort_cmp_fn_t)replmd_ldb_message_element_attid_sort);
206 static int replmd_op_callback(struct ldb_request *req, struct ldb_reply *ares)
208 struct ldb_context *ldb;
209 struct replmd_replicated_request *ac;
211 ac = talloc_get_type(req->context, struct replmd_replicated_request);
212 ldb = ldb_module_get_ctx(ac->module);
215 return ldb_module_done(ac->req, NULL, NULL,
216 LDB_ERR_OPERATIONS_ERROR);
218 if (ares->error != LDB_SUCCESS) {
219 return ldb_module_done(ac->req, ares->controls,
220 ares->response, ares->error);
223 if (ares->type != LDB_REPLY_DONE) {
224 ldb_set_errstring(ldb,
225 "invalid ldb_reply_type in callback");
227 return ldb_module_done(ac->req, NULL, NULL,
228 LDB_ERR_OPERATIONS_ERROR);
231 return ldb_module_done(ac->req, ares->controls,
232 ares->response, LDB_SUCCESS);
235 static int replmd_add(struct ldb_module *module, struct ldb_request *req)
237 struct ldb_context *ldb;
238 struct replmd_replicated_request *ac;
239 const struct dsdb_schema *schema;
240 enum ndr_err_code ndr_err;
241 struct ldb_request *down_req;
242 struct ldb_message *msg;
243 const struct dsdb_attribute *rdn_attr = NULL;
245 struct ldb_val guid_value;
246 struct replPropertyMetaDataBlob nmd;
247 struct ldb_val nmd_value;
249 const struct GUID *our_invocation_id;
250 time_t t = time(NULL);
256 /* do not manipulate our control entries */
257 if (ldb_dn_is_special(req->op.add.message->dn)) {
258 return ldb_next_request(module, req);
261 ldb = ldb_module_get_ctx(module);
263 ldb_debug(ldb, LDB_DEBUG_TRACE, "replmd_add\n");
265 schema = dsdb_get_schema(ldb);
267 ldb_debug_set(ldb, LDB_DEBUG_FATAL,
268 "replmd_modify: no dsdb_schema loaded");
269 return LDB_ERR_CONSTRAINT_VIOLATION;
272 ac = replmd_ctx_init(module, req);
274 return LDB_ERR_OPERATIONS_ERROR;
279 if (ldb_msg_find_element(req->op.add.message, "objectGUID") != NULL) {
280 ldb_debug_set(ldb, LDB_DEBUG_ERROR,
281 "replmd_add: it's not allowed to add an object with objectGUID\n");
282 return LDB_ERR_UNWILLING_TO_PERFORM;
285 /* Get a sequence number from the backend */
286 ret = ldb_sequence_number(ldb, LDB_SEQ_NEXT, &seq_num);
287 if (ret != LDB_SUCCESS) {
292 guid = GUID_random();
294 /* get our invicationId */
295 our_invocation_id = samdb_ntds_invocation_id(ldb);
296 if (!our_invocation_id) {
297 ldb_debug_set(ldb, LDB_DEBUG_ERROR,
298 "replmd_add: unable to find invocationId\n");
299 return LDB_ERR_OPERATIONS_ERROR;
302 /* we have to copy the message as the caller might have it as a const */
303 msg = ldb_msg_copy_shallow(ac, req->op.add.message);
306 return LDB_ERR_OPERATIONS_ERROR;
309 /* generated times */
310 unix_to_nt_time(&now, t);
311 time_str = ldb_timestring(msg, t);
313 return LDB_ERR_OPERATIONS_ERROR;
317 * remove autogenerated attributes
319 ldb_msg_remove_attr(msg, "whenCreated");
320 ldb_msg_remove_attr(msg, "whenChanged");
321 ldb_msg_remove_attr(msg, "uSNCreated");
322 ldb_msg_remove_attr(msg, "uSNChanged");
323 ldb_msg_remove_attr(msg, "replPropertyMetaData");
326 * readd replicated attributes
328 ret = ldb_msg_add_string(msg, "whenCreated", time_str);
329 if (ret != LDB_SUCCESS) {
331 return LDB_ERR_OPERATIONS_ERROR;
334 /* build the replication meta_data */
337 nmd.ctr.ctr1.count = msg->num_elements;
338 nmd.ctr.ctr1.array = talloc_array(msg,
339 struct replPropertyMetaData1,
341 if (!nmd.ctr.ctr1.array) {
343 return LDB_ERR_OPERATIONS_ERROR;
346 for (i=0; i < msg->num_elements; i++) {
347 struct ldb_message_element *e = &msg->elements[i];
348 struct replPropertyMetaData1 *m = &nmd.ctr.ctr1.array[ni];
349 const struct dsdb_attribute *sa;
351 if (e->name[0] == '@') continue;
353 sa = dsdb_attribute_by_lDAPDisplayName(schema, e->name);
355 ldb_debug_set(ldb, LDB_DEBUG_ERROR,
356 "replmd_add: attribute '%s' not defined in schema\n",
358 return LDB_ERR_NO_SUCH_ATTRIBUTE;
361 if ((sa->systemFlags & 0x00000001) || (sa->systemFlags & 0x00000004)) {
362 /* if the attribute is not replicated (0x00000001)
363 * or constructed (0x00000004) it has no metadata
368 m->attid = sa->attributeID_id;
370 m->originating_change_time = now;
371 m->originating_invocation_id = *our_invocation_id;
372 m->originating_usn = seq_num;
373 m->local_usn = seq_num;
376 if (ldb_attr_cmp(e->name, ldb_dn_get_rdn_name(msg->dn))) {
381 /* fix meta data count */
382 nmd.ctr.ctr1.count = ni;
385 * sort meta data array, and move the rdn attribute entry to the end
387 replmd_replPropertyMetaDataCtr1_sort(&nmd.ctr.ctr1, &rdn_attr->attributeID_id);
389 /* generated NDR encoded values */
390 ndr_err = ndr_push_struct_blob(&guid_value, msg,
393 (ndr_push_flags_fn_t)ndr_push_GUID);
394 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
396 return LDB_ERR_OPERATIONS_ERROR;
398 ndr_err = ndr_push_struct_blob(&nmd_value, msg,
399 lp_iconv_convenience(ldb_get_opaque(ldb, "loadparm")),
401 (ndr_push_flags_fn_t)ndr_push_replPropertyMetaDataBlob);
402 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
404 return LDB_ERR_OPERATIONS_ERROR;
408 * add the autogenerated values
410 ret = ldb_msg_add_value(msg, "objectGUID", &guid_value, NULL);
411 if (ret != LDB_SUCCESS) {
413 return LDB_ERR_OPERATIONS_ERROR;
415 ret = ldb_msg_add_string(msg, "whenChanged", time_str);
416 if (ret != LDB_SUCCESS) {
418 return LDB_ERR_OPERATIONS_ERROR;
420 ret = samdb_msg_add_uint64(ldb, msg, msg, "uSNCreated", seq_num);
421 if (ret != LDB_SUCCESS) {
423 return LDB_ERR_OPERATIONS_ERROR;
425 ret = samdb_msg_add_uint64(ldb, msg, msg, "uSNChanged", seq_num);
426 if (ret != LDB_SUCCESS) {
428 return LDB_ERR_OPERATIONS_ERROR;
430 ret = ldb_msg_add_value(msg, "replPropertyMetaData", &nmd_value, NULL);
431 if (ret != LDB_SUCCESS) {
433 return LDB_ERR_OPERATIONS_ERROR;
437 * sort the attributes by attid before storing the object
439 replmd_ldb_message_sort(msg, schema);
441 ret = ldb_build_add_req(&down_req, ldb, ac,
444 ac, replmd_op_callback,
446 if (ret != LDB_SUCCESS) {
450 /* go on with the call chain */
451 return ldb_next_request(module, down_req);
454 static int replmd_modify(struct ldb_module *module, struct ldb_request *req)
456 struct ldb_context *ldb;
457 struct replmd_replicated_request *ac;
458 const struct dsdb_schema *schema;
459 struct ldb_request *down_req;
460 struct ldb_message *msg;
462 time_t t = time(NULL);
465 /* do not manipulate our control entries */
466 if (ldb_dn_is_special(req->op.mod.message->dn)) {
467 return ldb_next_request(module, req);
470 ldb = ldb_module_get_ctx(module);
472 ldb_debug(ldb, LDB_DEBUG_TRACE, "replmd_modify\n");
474 schema = dsdb_get_schema(ldb);
476 ldb_debug_set(ldb, LDB_DEBUG_FATAL,
477 "replmd_modify: no dsdb_schema loaded");
478 return LDB_ERR_CONSTRAINT_VIOLATION;
481 ac = replmd_ctx_init(module, req);
483 return LDB_ERR_OPERATIONS_ERROR;
488 /* we have to copy the message as the caller might have it as a const */
489 msg = ldb_msg_copy_shallow(ac, req->op.mod.message);
492 return LDB_ERR_OPERATIONS_ERROR;
496 * - get the whole old object
497 * - if the old object doesn't exist report an error
498 * - give an error when a readonly attribute should
500 * - merge the changed into the old object
501 * if the caller set values to the same value
502 * ignore the attribute, return success when no
503 * attribute was changed
504 * - calculate the new replPropertyMetaData attribute
507 if (add_time_element(msg, "whenChanged", t) != LDB_SUCCESS) {
509 return LDB_ERR_OPERATIONS_ERROR;
512 /* Get a sequence number from the backend */
513 ret = ldb_sequence_number(ldb, LDB_SEQ_NEXT, &seq_num);
514 if (ret == LDB_SUCCESS) {
515 if (add_uint64_element(msg, "uSNChanged", seq_num) != LDB_SUCCESS) {
517 return LDB_ERR_OPERATIONS_ERROR;
522 * - sort the attributes by attid with replmd_ldb_message_sort()
523 * - replace the old object with the newly constructed one
526 ret = ldb_build_mod_req(&down_req, ldb, ac,
529 ac, replmd_op_callback,
531 if (ret != LDB_SUCCESS) {
534 talloc_steal(down_req, msg);
536 /* go on with the call chain */
537 return ldb_next_request(module, down_req);
540 static int replmd_replicated_request_error(struct replmd_replicated_request *ar, int ret)
545 static int replmd_replicated_request_werror(struct replmd_replicated_request *ar, WERROR status)
547 int ret = LDB_ERR_OTHER;
548 /* TODO: do some error mapping */
552 static int replmd_replicated_apply_next(struct replmd_replicated_request *ar);
554 static int replmd_replicated_apply_add_callback(struct ldb_request *req,
555 struct ldb_reply *ares)
557 struct ldb_context *ldb;
558 struct replmd_replicated_request *ar = talloc_get_type(req->context,
559 struct replmd_replicated_request);
562 ldb = ldb_module_get_ctx(ar->module);
565 return ldb_module_done(ar->req, NULL, NULL,
566 LDB_ERR_OPERATIONS_ERROR);
568 if (ares->error != LDB_SUCCESS) {
569 return ldb_module_done(ar->req, ares->controls,
570 ares->response, ares->error);
573 if (ares->type != LDB_REPLY_DONE) {
574 ldb_set_errstring(ldb, "Invalid reply type\n!");
575 return ldb_module_done(ar->req, NULL, NULL,
576 LDB_ERR_OPERATIONS_ERROR);
582 ret = replmd_replicated_apply_next(ar);
583 if (ret != LDB_SUCCESS) {
584 return ldb_module_done(ar->req, NULL, NULL, ret);
590 static int replmd_replicated_apply_add(struct replmd_replicated_request *ar)
592 struct ldb_context *ldb;
593 struct ldb_request *change_req;
594 enum ndr_err_code ndr_err;
595 struct ldb_message *msg;
596 struct replPropertyMetaDataBlob *md;
597 struct ldb_val md_value;
603 * TODO: check if the parent object exist
607 * TODO: handle the conflict case where an object with the
611 ldb = ldb_module_get_ctx(ar->module);
612 msg = ar->objs->objects[ar->index_current].msg;
613 md = ar->objs->objects[ar->index_current].meta_data;
615 ret = ldb_sequence_number(ldb, LDB_SEQ_NEXT, &seq_num);
616 if (ret != LDB_SUCCESS) {
617 return replmd_replicated_request_error(ar, ret);
620 ret = ldb_msg_add_value(msg, "objectGUID", &ar->objs->objects[ar->index_current].guid_value, NULL);
621 if (ret != LDB_SUCCESS) {
622 return replmd_replicated_request_error(ar, ret);
625 ret = ldb_msg_add_string(msg, "whenChanged", ar->objs->objects[ar->index_current].when_changed);
626 if (ret != LDB_SUCCESS) {
627 return replmd_replicated_request_error(ar, ret);
630 ret = samdb_msg_add_uint64(ldb, msg, msg, "uSNCreated", seq_num);
631 if (ret != LDB_SUCCESS) {
632 return replmd_replicated_request_error(ar, ret);
635 ret = samdb_msg_add_uint64(ldb, msg, msg, "uSNChanged", seq_num);
636 if (ret != LDB_SUCCESS) {
637 return replmd_replicated_request_error(ar, ret);
641 * the meta data array is already sorted by the caller
643 for (i=0; i < md->ctr.ctr1.count; i++) {
644 md->ctr.ctr1.array[i].local_usn = seq_num;
646 ndr_err = ndr_push_struct_blob(&md_value, msg,
647 lp_iconv_convenience(ldb_get_opaque(ldb, "loadparm")),
649 (ndr_push_flags_fn_t)ndr_push_replPropertyMetaDataBlob);
650 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
651 NTSTATUS nt_status = ndr_map_error2ntstatus(ndr_err);
652 return replmd_replicated_request_werror(ar, ntstatus_to_werror(nt_status));
654 ret = ldb_msg_add_value(msg, "replPropertyMetaData", &md_value, NULL);
655 if (ret != LDB_SUCCESS) {
656 return replmd_replicated_request_error(ar, ret);
659 replmd_ldb_message_sort(msg, ar->schema);
661 ret = ldb_build_add_req(&change_req,
667 replmd_replicated_apply_add_callback,
669 if (ret != LDB_SUCCESS) return replmd_replicated_request_error(ar, ret);
671 return ldb_next_request(ar->module, change_req);
674 static int replmd_replPropertyMetaData1_conflict_compare(struct replPropertyMetaData1 *m1,
675 struct replPropertyMetaData1 *m2)
679 if (m1->version != m2->version) {
680 return m1->version - m2->version;
683 if (m1->originating_change_time != m2->originating_change_time) {
684 return m1->originating_change_time - m2->originating_change_time;
687 ret = GUID_compare(&m1->originating_invocation_id, &m2->originating_invocation_id);
692 return m1->originating_usn - m2->originating_usn;
695 static int replmd_replicated_apply_merge_callback(struct ldb_request *req,
696 struct ldb_reply *ares)
698 struct ldb_context *ldb;
699 struct replmd_replicated_request *ar = talloc_get_type(req->context,
700 struct replmd_replicated_request);
703 ldb = ldb_module_get_ctx(ar->module);
706 return ldb_module_done(ar->req, NULL, NULL,
707 LDB_ERR_OPERATIONS_ERROR);
709 if (ares->error != LDB_SUCCESS) {
710 return ldb_module_done(ar->req, ares->controls,
711 ares->response, ares->error);
714 if (ares->type != LDB_REPLY_DONE) {
715 ldb_set_errstring(ldb, "Invalid reply type\n!");
716 return ldb_module_done(ar->req, NULL, NULL,
717 LDB_ERR_OPERATIONS_ERROR);
723 ret = replmd_replicated_apply_next(ar);
724 if (ret != LDB_SUCCESS) {
725 return ldb_module_done(ar->req, NULL, NULL, ret);
731 static int replmd_replicated_apply_merge(struct replmd_replicated_request *ar)
733 struct ldb_context *ldb;
734 struct ldb_request *change_req;
735 enum ndr_err_code ndr_err;
736 struct ldb_message *msg;
737 struct replPropertyMetaDataBlob *rmd;
738 struct replPropertyMetaDataBlob omd;
739 const struct ldb_val *omd_value;
740 struct replPropertyMetaDataBlob nmd;
741 struct ldb_val nmd_value;
743 uint32_t removed_attrs = 0;
747 ldb = ldb_module_get_ctx(ar->module);
748 msg = ar->objs->objects[ar->index_current].msg;
749 rmd = ar->objs->objects[ar->index_current].meta_data;
754 * TODO: add rename conflict handling
756 if (ldb_dn_compare(msg->dn, ar->search_msg->dn) != 0) {
757 ldb_debug_set(ldb, LDB_DEBUG_FATAL, "replmd_replicated_apply_merge[%u]: rename not supported",
759 ldb_debug(ldb, LDB_DEBUG_FATAL, "%s => %s\n",
760 ldb_dn_get_linearized(ar->search_msg->dn),
761 ldb_dn_get_linearized(msg->dn));
762 return replmd_replicated_request_werror(ar, WERR_NOT_SUPPORTED);
765 ret = ldb_sequence_number(ldb, LDB_SEQ_NEXT, &seq_num);
766 if (ret != LDB_SUCCESS) {
767 return replmd_replicated_request_error(ar, ret);
770 /* find existing meta data */
771 omd_value = ldb_msg_find_ldb_val(ar->search_msg, "replPropertyMetaData");
773 ndr_err = ndr_pull_struct_blob(omd_value, ar,
774 lp_iconv_convenience(ldb_get_opaque(ldb, "loadparm")), &omd,
775 (ndr_pull_flags_fn_t)ndr_pull_replPropertyMetaDataBlob);
776 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
777 NTSTATUS nt_status = ndr_map_error2ntstatus(ndr_err);
778 return replmd_replicated_request_werror(ar, ntstatus_to_werror(nt_status));
781 if (omd.version != 1) {
782 return replmd_replicated_request_werror(ar, WERR_DS_DRA_INTERNAL_ERROR);
788 nmd.ctr.ctr1.count = omd.ctr.ctr1.count + rmd->ctr.ctr1.count;
789 nmd.ctr.ctr1.array = talloc_array(ar,
790 struct replPropertyMetaData1,
792 if (!nmd.ctr.ctr1.array) return replmd_replicated_request_werror(ar, WERR_NOMEM);
794 /* first copy the old meta data */
795 for (i=0; i < omd.ctr.ctr1.count; i++) {
796 nmd.ctr.ctr1.array[ni] = omd.ctr.ctr1.array[i];
800 /* now merge in the new meta data */
801 for (i=0; i < rmd->ctr.ctr1.count; i++) {
804 rmd->ctr.ctr1.array[i].local_usn = seq_num;
806 for (j=0; j < ni; j++) {
809 if (rmd->ctr.ctr1.array[i].attid != nmd.ctr.ctr1.array[j].attid) {
813 cmp = replmd_replPropertyMetaData1_conflict_compare(&rmd->ctr.ctr1.array[i],
814 &nmd.ctr.ctr1.array[j]);
816 /* replace the entry */
817 nmd.ctr.ctr1.array[j] = rmd->ctr.ctr1.array[i];
822 /* we don't want to apply this change so remove the attribute */
823 ldb_msg_remove_element(msg, &msg->elements[i-removed_attrs]);
832 nmd.ctr.ctr1.array[ni] = rmd->ctr.ctr1.array[i];
837 * finally correct the size of the meta_data array
839 nmd.ctr.ctr1.count = ni;
842 * the rdn attribute (the alias for the name attribute),
843 * 'cn' for most objects is the last entry in the meta data array
846 * sort the new meta data array
849 struct replPropertyMetaData1 *rdn_p;
850 uint32_t rdn_idx = omd.ctr.ctr1.count - 1;
852 rdn_p = &nmd.ctr.ctr1.array[rdn_idx];
853 replmd_replPropertyMetaDataCtr1_sort(&nmd.ctr.ctr1, &rdn_p->attid);
856 /* create the meta data value */
857 ndr_err = ndr_push_struct_blob(&nmd_value, msg,
858 lp_iconv_convenience(ldb_get_opaque(ldb, "loadparm")),
860 (ndr_push_flags_fn_t)ndr_push_replPropertyMetaDataBlob);
861 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
862 NTSTATUS nt_status = ndr_map_error2ntstatus(ndr_err);
863 return replmd_replicated_request_werror(ar, ntstatus_to_werror(nt_status));
867 * check if some replicated attributes left, otherwise skip the ldb_modify() call
869 if (msg->num_elements == 0) {
870 ldb_debug(ldb, LDB_DEBUG_TRACE, "replmd_replicated_apply_merge[%u]: skip replace\n",
874 return replmd_replicated_apply_next(ar);
877 ldb_debug(ldb, LDB_DEBUG_TRACE, "replmd_replicated_apply_merge[%u]: replace %u attributes\n",
878 ar->index_current, msg->num_elements);
881 * when we know that we'll modify the record, add the whenChanged, uSNChanged
882 * and replPopertyMetaData attributes
884 ret = ldb_msg_add_string(msg, "whenChanged", ar->objs->objects[ar->index_current].when_changed);
885 if (ret != LDB_SUCCESS) {
886 return replmd_replicated_request_error(ar, ret);
888 ret = samdb_msg_add_uint64(ldb, msg, msg, "uSNChanged", seq_num);
889 if (ret != LDB_SUCCESS) {
890 return replmd_replicated_request_error(ar, ret);
892 ret = ldb_msg_add_value(msg, "replPropertyMetaData", &nmd_value, NULL);
893 if (ret != LDB_SUCCESS) {
894 return replmd_replicated_request_error(ar, ret);
897 replmd_ldb_message_sort(msg, ar->schema);
899 /* we want to replace the old values */
900 for (i=0; i < msg->num_elements; i++) {
901 msg->elements[i].flags = LDB_FLAG_MOD_REPLACE;
904 ret = ldb_build_mod_req(&change_req,
910 replmd_replicated_apply_merge_callback,
912 if (ret != LDB_SUCCESS) return replmd_replicated_request_error(ar, ret);
914 return ldb_next_request(ar->module, change_req);
917 static int replmd_replicated_apply_search_callback(struct ldb_request *req,
918 struct ldb_reply *ares)
920 struct replmd_replicated_request *ar = talloc_get_type(req->context,
921 struct replmd_replicated_request);
925 return ldb_module_done(ar->req, NULL, NULL,
926 LDB_ERR_OPERATIONS_ERROR);
928 if (ares->error != LDB_SUCCESS &&
929 ares->error != LDB_ERR_NO_SUCH_OBJECT) {
930 return ldb_module_done(ar->req, ares->controls,
931 ares->response, ares->error);
934 switch (ares->type) {
935 case LDB_REPLY_ENTRY:
936 ar->search_msg = talloc_steal(ar, ares->message);
939 case LDB_REPLY_REFERRAL:
940 /* we ignore referrals */
944 if (ar->search_msg != NULL) {
945 ret = replmd_replicated_apply_merge(ar);
947 ret = replmd_replicated_apply_add(ar);
949 if (ret != LDB_SUCCESS) {
950 return ldb_module_done(ar->req, NULL, NULL, ret);
958 static int replmd_replicated_uptodate_vector(struct replmd_replicated_request *ar);
960 static int replmd_replicated_apply_next(struct replmd_replicated_request *ar)
962 struct ldb_context *ldb;
966 struct ldb_request *search_req;
968 if (ar->index_current >= ar->objs->num_objects) {
969 /* done with it, go to the last op */
970 return replmd_replicated_uptodate_vector(ar);
973 ldb = ldb_module_get_ctx(ar->module);
974 ar->search_msg = NULL;
976 tmp_str = ldb_binary_encode(ar, ar->objs->objects[ar->index_current].guid_value);
977 if (!tmp_str) return replmd_replicated_request_werror(ar, WERR_NOMEM);
979 filter = talloc_asprintf(ar, "(objectGUID=%s)", tmp_str);
980 if (!filter) return replmd_replicated_request_werror(ar, WERR_NOMEM);
981 talloc_free(tmp_str);
983 ret = ldb_build_search_req(&search_req,
986 ar->objs->partition_dn,
992 replmd_replicated_apply_search_callback,
994 if (ret != LDB_SUCCESS) return replmd_replicated_request_error(ar, ret);
996 return ldb_next_request(ar->module, search_req);
999 static int replmd_replicated_uptodate_modify_callback(struct ldb_request *req,
1000 struct ldb_reply *ares)
1002 struct ldb_context *ldb;
1003 struct replmd_replicated_request *ar = talloc_get_type(req->context,
1004 struct replmd_replicated_request);
1005 ldb = ldb_module_get_ctx(ar->module);
1008 return ldb_module_done(ar->req, NULL, NULL,
1009 LDB_ERR_OPERATIONS_ERROR);
1011 if (ares->error != LDB_SUCCESS) {
1012 return ldb_module_done(ar->req, ares->controls,
1013 ares->response, ares->error);
1016 if (ares->type != LDB_REPLY_DONE) {
1017 ldb_set_errstring(ldb, "Invalid reply type\n!");
1018 return ldb_module_done(ar->req, NULL, NULL,
1019 LDB_ERR_OPERATIONS_ERROR);
1024 return ldb_module_done(ar->req, NULL, NULL, LDB_SUCCESS);
1027 static int replmd_drsuapi_DsReplicaCursor2_compare(const struct drsuapi_DsReplicaCursor2 *c1,
1028 const struct drsuapi_DsReplicaCursor2 *c2)
1030 return GUID_compare(&c1->source_dsa_invocation_id, &c2->source_dsa_invocation_id);
1033 static int replmd_replicated_uptodate_modify(struct replmd_replicated_request *ar)
1035 struct ldb_context *ldb;
1036 struct ldb_request *change_req;
1037 enum ndr_err_code ndr_err;
1038 struct ldb_message *msg;
1039 struct replUpToDateVectorBlob ouv;
1040 const struct ldb_val *ouv_value;
1041 const struct drsuapi_DsReplicaCursor2CtrEx *ruv;
1042 struct replUpToDateVectorBlob nuv;
1043 struct ldb_val nuv_value;
1044 struct ldb_message_element *nuv_el = NULL;
1045 const struct GUID *our_invocation_id;
1046 struct ldb_message_element *orf_el = NULL;
1047 struct repsFromToBlob nrf;
1048 struct ldb_val *nrf_value = NULL;
1049 struct ldb_message_element *nrf_el = NULL;
1053 time_t t = time(NULL);
1057 ldb = ldb_module_get_ctx(ar->module);
1058 ruv = ar->objs->uptodateness_vector;
1064 unix_to_nt_time(&now, t);
1067 * we use the next sequence number for our own highest_usn
1068 * because we will do a modify request and this will increment
1071 ret = ldb_sequence_number(ldb, LDB_SEQ_NEXT, &seq_num);
1072 if (ret != LDB_SUCCESS) {
1073 return replmd_replicated_request_error(ar, ret);
1077 * first create the new replUpToDateVector
1079 ouv_value = ldb_msg_find_ldb_val(ar->search_msg, "replUpToDateVector");
1081 ndr_err = ndr_pull_struct_blob(ouv_value, ar,
1082 lp_iconv_convenience(ldb_get_opaque(ldb, "loadparm")), &ouv,
1083 (ndr_pull_flags_fn_t)ndr_pull_replUpToDateVectorBlob);
1084 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1085 NTSTATUS nt_status = ndr_map_error2ntstatus(ndr_err);
1086 return replmd_replicated_request_werror(ar, ntstatus_to_werror(nt_status));
1089 if (ouv.version != 2) {
1090 return replmd_replicated_request_werror(ar, WERR_DS_DRA_INTERNAL_ERROR);
1095 * the new uptodateness vector will at least
1096 * contain 1 entry, one for the source_dsa
1098 * plus optional values from our old vector and the one from the source_dsa
1100 nuv.ctr.ctr2.count = 1 + ouv.ctr.ctr2.count;
1101 if (ruv) nuv.ctr.ctr2.count += ruv->count;
1102 nuv.ctr.ctr2.cursors = talloc_array(ar,
1103 struct drsuapi_DsReplicaCursor2,
1104 nuv.ctr.ctr2.count);
1105 if (!nuv.ctr.ctr2.cursors) return replmd_replicated_request_werror(ar, WERR_NOMEM);
1107 /* first copy the old vector */
1108 for (i=0; i < ouv.ctr.ctr2.count; i++) {
1109 nuv.ctr.ctr2.cursors[ni] = ouv.ctr.ctr2.cursors[i];
1113 /* get our invocation_id if we have one already attached to the ldb */
1114 our_invocation_id = samdb_ntds_invocation_id(ldb);
1116 /* merge in the source_dsa vector is available */
1117 for (i=0; (ruv && i < ruv->count); i++) {
1120 if (our_invocation_id &&
1121 GUID_equal(&ruv->cursors[i].source_dsa_invocation_id,
1122 our_invocation_id)) {
1126 for (j=0; j < ni; j++) {
1127 if (!GUID_equal(&ruv->cursors[i].source_dsa_invocation_id,
1128 &nuv.ctr.ctr2.cursors[j].source_dsa_invocation_id)) {
1135 * we update only the highest_usn and not the latest_sync_success time,
1136 * because the last success stands for direct replication
1138 if (ruv->cursors[i].highest_usn > nuv.ctr.ctr2.cursors[j].highest_usn) {
1139 nuv.ctr.ctr2.cursors[j].highest_usn = ruv->cursors[i].highest_usn;
1144 if (found) continue;
1146 /* if it's not there yet, add it */
1147 nuv.ctr.ctr2.cursors[ni] = ruv->cursors[i];
1152 * merge in the current highwatermark for the source_dsa
1155 for (j=0; j < ni; j++) {
1156 if (!GUID_equal(&ar->objs->source_dsa->source_dsa_invocation_id,
1157 &nuv.ctr.ctr2.cursors[j].source_dsa_invocation_id)) {
1164 * here we update the highest_usn and last_sync_success time
1165 * because we're directly replicating from the source_dsa
1167 * and use the tmp_highest_usn because this is what we have just applied
1170 nuv.ctr.ctr2.cursors[j].highest_usn = ar->objs->source_dsa->highwatermark.tmp_highest_usn;
1171 nuv.ctr.ctr2.cursors[j].last_sync_success = now;
1176 * here we update the highest_usn and last_sync_success time
1177 * because we're directly replicating from the source_dsa
1179 * and use the tmp_highest_usn because this is what we have just applied
1182 nuv.ctr.ctr2.cursors[ni].source_dsa_invocation_id= ar->objs->source_dsa->source_dsa_invocation_id;
1183 nuv.ctr.ctr2.cursors[ni].highest_usn = ar->objs->source_dsa->highwatermark.tmp_highest_usn;
1184 nuv.ctr.ctr2.cursors[ni].last_sync_success = now;
1189 * finally correct the size of the cursors array
1191 nuv.ctr.ctr2.count = ni;
1196 qsort(nuv.ctr.ctr2.cursors, nuv.ctr.ctr2.count,
1197 sizeof(struct drsuapi_DsReplicaCursor2),
1198 (comparison_fn_t)replmd_drsuapi_DsReplicaCursor2_compare);
1201 * create the change ldb_message
1203 msg = ldb_msg_new(ar);
1204 if (!msg) return replmd_replicated_request_werror(ar, WERR_NOMEM);
1205 msg->dn = ar->search_msg->dn;
1207 ndr_err = ndr_push_struct_blob(&nuv_value, msg,
1208 lp_iconv_convenience(ldb_get_opaque(ldb, "loadparm")),
1210 (ndr_push_flags_fn_t)ndr_push_replUpToDateVectorBlob);
1211 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1212 NTSTATUS nt_status = ndr_map_error2ntstatus(ndr_err);
1213 return replmd_replicated_request_werror(ar, ntstatus_to_werror(nt_status));
1215 ret = ldb_msg_add_value(msg, "replUpToDateVector", &nuv_value, &nuv_el);
1216 if (ret != LDB_SUCCESS) {
1217 return replmd_replicated_request_error(ar, ret);
1219 nuv_el->flags = LDB_FLAG_MOD_REPLACE;
1222 * now create the new repsFrom value from the given repsFromTo1 structure
1226 nrf.ctr.ctr1 = *ar->objs->source_dsa;
1227 /* and fix some values... */
1228 nrf.ctr.ctr1.consecutive_sync_failures = 0;
1229 nrf.ctr.ctr1.last_success = now;
1230 nrf.ctr.ctr1.last_attempt = now;
1231 nrf.ctr.ctr1.result_last_attempt = WERR_OK;
1232 nrf.ctr.ctr1.highwatermark.highest_usn = nrf.ctr.ctr1.highwatermark.tmp_highest_usn;
1235 * first see if we already have a repsFrom value for the current source dsa
1236 * if so we'll later replace this value
1238 orf_el = ldb_msg_find_element(ar->search_msg, "repsFrom");
1240 for (i=0; i < orf_el->num_values; i++) {
1241 struct repsFromToBlob *trf;
1243 trf = talloc(ar, struct repsFromToBlob);
1244 if (!trf) return replmd_replicated_request_werror(ar, WERR_NOMEM);
1246 ndr_err = ndr_pull_struct_blob(&orf_el->values[i], trf, lp_iconv_convenience(ldb_get_opaque(ldb, "loadparm")), trf,
1247 (ndr_pull_flags_fn_t)ndr_pull_repsFromToBlob);
1248 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1249 NTSTATUS nt_status = ndr_map_error2ntstatus(ndr_err);
1250 return replmd_replicated_request_werror(ar, ntstatus_to_werror(nt_status));
1253 if (trf->version != 1) {
1254 return replmd_replicated_request_werror(ar, WERR_DS_DRA_INTERNAL_ERROR);
1258 * we compare the source dsa objectGUID not the invocation_id
1259 * because we want only one repsFrom value per source dsa
1260 * and when the invocation_id of the source dsa has changed we don't need
1261 * the old repsFrom with the old invocation_id
1263 if (!GUID_equal(&trf->ctr.ctr1.source_dsa_obj_guid,
1264 &ar->objs->source_dsa->source_dsa_obj_guid)) {
1270 nrf_value = &orf_el->values[i];
1275 * copy over all old values to the new ldb_message
1277 ret = ldb_msg_add_empty(msg, "repsFrom", 0, &nrf_el);
1278 if (ret != LDB_SUCCESS) return replmd_replicated_request_error(ar, ret);
1283 * if we haven't found an old repsFrom value for the current source dsa
1284 * we'll add a new value
1287 struct ldb_val zero_value;
1288 ZERO_STRUCT(zero_value);
1289 ret = ldb_msg_add_value(msg, "repsFrom", &zero_value, &nrf_el);
1290 if (ret != LDB_SUCCESS) return replmd_replicated_request_error(ar, ret);
1292 nrf_value = &nrf_el->values[nrf_el->num_values - 1];
1295 /* we now fill the value which is already attached to ldb_message */
1296 ndr_err = ndr_push_struct_blob(nrf_value, msg,
1297 lp_iconv_convenience(ldb_get_opaque(ldb, "loadparm")),
1299 (ndr_push_flags_fn_t)ndr_push_repsFromToBlob);
1300 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1301 NTSTATUS nt_status = ndr_map_error2ntstatus(ndr_err);
1302 return replmd_replicated_request_werror(ar, ntstatus_to_werror(nt_status));
1306 * the ldb_message_element for the attribute, has all the old values and the new one
1307 * so we'll replace the whole attribute with all values
1309 nrf_el->flags = LDB_FLAG_MOD_REPLACE;
1311 /* prepare the ldb_modify() request */
1312 ret = ldb_build_mod_req(&change_req,
1318 replmd_replicated_uptodate_modify_callback,
1320 if (ret != LDB_SUCCESS) return replmd_replicated_request_error(ar, ret);
1322 return ldb_next_request(ar->module, change_req);
1325 static int replmd_replicated_uptodate_search_callback(struct ldb_request *req,
1326 struct ldb_reply *ares)
1328 struct replmd_replicated_request *ar = talloc_get_type(req->context,
1329 struct replmd_replicated_request);
1333 return ldb_module_done(ar->req, NULL, NULL,
1334 LDB_ERR_OPERATIONS_ERROR);
1336 if (ares->error != LDB_SUCCESS &&
1337 ares->error != LDB_ERR_NO_SUCH_OBJECT) {
1338 return ldb_module_done(ar->req, ares->controls,
1339 ares->response, ares->error);
1342 switch (ares->type) {
1343 case LDB_REPLY_ENTRY:
1344 ar->search_msg = talloc_steal(ar, ares->message);
1347 case LDB_REPLY_REFERRAL:
1348 /* we ignore referrals */
1351 case LDB_REPLY_DONE:
1352 if (ar->search_msg == NULL) {
1353 ret = replmd_replicated_request_werror(ar, WERR_DS_DRA_INTERNAL_ERROR);
1355 ret = replmd_replicated_uptodate_modify(ar);
1357 if (ret != LDB_SUCCESS) {
1358 return ldb_module_done(ar->req, NULL, NULL, ret);
1367 static int replmd_replicated_uptodate_vector(struct replmd_replicated_request *ar)
1369 struct ldb_context *ldb;
1371 static const char *attrs[] = {
1372 "replUpToDateVector",
1376 struct ldb_request *search_req;
1378 ldb = ldb_module_get_ctx(ar->module);
1379 ar->search_msg = NULL;
1381 ret = ldb_build_search_req(&search_req,
1384 ar->objs->partition_dn,
1390 replmd_replicated_uptodate_search_callback,
1392 if (ret != LDB_SUCCESS) return replmd_replicated_request_error(ar, ret);
1394 return ldb_next_request(ar->module, search_req);
1397 static int replmd_extended_replicated_objects(struct ldb_module *module, struct ldb_request *req)
1399 struct ldb_context *ldb;
1400 struct dsdb_extended_replicated_objects *objs;
1401 struct replmd_replicated_request *ar;
1402 struct ldb_control **ctrls;
1405 ldb = ldb_module_get_ctx(module);
1407 ldb_debug(ldb, LDB_DEBUG_TRACE, "replmd_extended_replicated_objects\n");
1409 objs = talloc_get_type(req->op.extended.data, struct dsdb_extended_replicated_objects);
1411 ldb_debug(ldb, LDB_DEBUG_FATAL, "replmd_extended_replicated_objects: invalid extended data\n");
1412 return LDB_ERR_PROTOCOL_ERROR;
1415 if (objs->version != DSDB_EXTENDED_REPLICATED_OBJECTS_VERSION) {
1416 ldb_debug(ldb, LDB_DEBUG_FATAL, "replmd_extended_replicated_objects: extended data invalid version [%u != %u]\n",
1417 objs->version, DSDB_EXTENDED_REPLICATED_OBJECTS_VERSION);
1418 return LDB_ERR_PROTOCOL_ERROR;
1421 ar = replmd_ctx_init(module, req);
1423 return LDB_ERR_OPERATIONS_ERROR;
1426 ar->schema = dsdb_get_schema(ldb);
1428 ldb_debug_set(ldb, LDB_DEBUG_FATAL, "replmd_ctx_init: no loaded schema found\n");
1430 return LDB_ERR_CONSTRAINT_VIOLATION;
1433 ctrls = req->controls;
1435 if (req->controls) {
1436 req->controls = talloc_memdup(ar, req->controls,
1437 talloc_get_size(req->controls));
1438 if (!req->controls) return replmd_replicated_request_werror(ar, WERR_NOMEM);
1441 ret = ldb_request_add_control(req, DSDB_CONTROL_REPLICATED_UPDATE_OID, false, NULL);
1442 if (ret != LDB_SUCCESS) {
1446 ar->controls = req->controls;
1447 req->controls = ctrls;
1449 return replmd_replicated_apply_next(ar);
1452 static int replmd_extended(struct ldb_module *module, struct ldb_request *req)
1454 if (strcmp(req->op.extended.oid, DSDB_EXTENDED_REPLICATED_OBJECTS_OID) == 0) {
1455 return replmd_extended_replicated_objects(module, req);
1458 return ldb_next_request(module, req);
1461 _PUBLIC_ const struct ldb_module_ops ldb_repl_meta_data_module_ops = {
1462 .name = "repl_meta_data",
1464 .modify = replmd_modify,
1465 .extended = replmd_extended,