#include "libcli/auth/libcli_auth.h"
#include "param/param.h"
-/**
- * Multi-pass working schema creation
- * Function will:
- * - shallow copy initial schema supplied
- * - create a working schema in multiple passes
- * until all objects are resolved
- * Working schema is a schema with Attributes, Classes
- * and indexes, but w/o subClassOf, possibleSupperiors etc.
- * It is to be used just us cache for converting attribute values.
- */
-WERROR dsdb_repl_make_working_schema(struct ldb_context *ldb,
- const struct dsdb_schema *initial_schema,
- const struct drsuapi_DsReplicaOIDMapping_Ctr *mapping_ctr,
- uint32_t object_count,
- const struct drsuapi_DsReplicaObjectListItemEx *first_object,
- const DATA_BLOB *gensec_skey,
- TALLOC_CTX *mem_ctx,
- struct dsdb_schema **_schema_out)
+#undef DBGC_CLASS
+#define DBGC_CLASS DBGC_DRS_REPL
+
+static WERROR dsdb_repl_merge_working_schema(struct ldb_context *ldb,
+ struct dsdb_schema *dest_schema,
+ const struct dsdb_schema *ref_schema)
+{
+ const struct dsdb_class *cur_class = NULL;
+ const struct dsdb_attribute *cur_attr = NULL;
+ int ret;
+
+ for (cur_class = ref_schema->classes;
+ cur_class;
+ cur_class = cur_class->next)
+ {
+ const struct dsdb_class *tmp1;
+ struct dsdb_class *tmp2;
+
+ tmp1 = dsdb_class_by_governsID_id(dest_schema,
+ cur_class->governsID_id);
+ if (tmp1 != NULL) {
+ continue;
+ }
+
+ /*
+ * Do a shallow copy so that original next and prev are
+ * not modified, we don't need to do a deep copy
+ * as the rest won't be modified and this is for
+ * a short lived object.
+ */
+ tmp2 = talloc(dest_schema, struct dsdb_class);
+ if (tmp2 == NULL) {
+ return WERR_NOT_ENOUGH_MEMORY;
+ }
+ *tmp2 = *cur_class;
+ DLIST_ADD(dest_schema->classes, tmp2);
+ }
+
+ for (cur_attr = ref_schema->attributes;
+ cur_attr;
+ cur_attr = cur_attr->next)
+ {
+ const struct dsdb_attribute *tmp1;
+ struct dsdb_attribute *tmp2;
+
+ tmp1 = dsdb_attribute_by_attributeID_id(dest_schema,
+ cur_attr->attributeID_id);
+ if (tmp1 != NULL) {
+ continue;
+ }
+
+ /*
+ * Do a shallow copy so that original next and prev are
+ * not modified, we don't need to do a deep copy
+ * as the rest won't be modified and this is for
+ * a short lived object.
+ */
+ tmp2 = talloc(dest_schema, struct dsdb_attribute);
+ if (tmp2 == NULL) {
+ return WERR_NOT_ENOUGH_MEMORY;
+ }
+ *tmp2 = *cur_attr;
+ DLIST_ADD(dest_schema->attributes, tmp2);
+ }
+
+ ret = dsdb_setup_sorted_accessors(ldb, dest_schema);
+ if (LDB_SUCCESS != ret) {
+ DEBUG(0,("Failed to add new attribute to reference schema!\n"));
+ return WERR_INTERNAL_ERROR;
+ }
+
+ return WERR_OK;
+}
+
+WERROR dsdb_repl_resolve_working_schema(struct ldb_context *ldb,
+ struct dsdb_schema_prefixmap *pfm_remote,
+ uint32_t cycle_before_switching,
+ struct dsdb_schema *initial_schema,
+ struct dsdb_schema *resulting_schema,
+ uint32_t object_count,
+ const struct drsuapi_DsReplicaObjectListItemEx *first_object)
{
struct schema_list {
struct schema_list *next, *prev;
const struct drsuapi_DsReplicaObjectListItemEx *obj;
};
-
- WERROR werr;
- struct dsdb_schema_prefixmap *pfm_remote;
struct schema_list *schema_list = NULL, *schema_list_item, *schema_list_next_item;
+ WERROR werr;
struct dsdb_schema *working_schema;
const struct drsuapi_DsReplicaObjectListItemEx *cur;
+ DATA_BLOB empty_key = data_blob_null;
int ret, pass_no;
uint32_t ignore_attids[] = {
DRSUAPI_ATTID_auxiliaryClass,
DRSUAPI_ATTID_systemPossSuperiors,
DRSUAPI_ATTID_INVALID
};
-
- /* make a copy of the iniatial_scheam so we don't mess with it */
- working_schema = dsdb_schema_copy_shallow(mem_ctx, ldb, initial_schema);
- if (!working_schema) {
- DEBUG(0,(__location__ ": schema copy failed!\n"));
- return WERR_NOMEM;
- }
-
- /* we are going to need remote prefixMap for decoding */
- werr = dsdb_schema_pfm_from_drsuapi_pfm(mapping_ctr, true,
- mem_ctx, &pfm_remote, NULL);
- if (!W_ERROR_IS_OK(werr)) {
- DEBUG(0,(__location__ ": Failed to decode remote prefixMap: %s",
- win_errstr(werr)));
- return werr;
- }
+ TALLOC_CTX *frame = talloc_stackframe();
/* create a list of objects yet to be converted */
for (cur = first_object; cur; cur = cur->next_object) {
- schema_list_item = talloc(mem_ctx, struct schema_list);
+ schema_list_item = talloc(frame, struct schema_list);
+ if (schema_list_item == NULL) {
+ return WERR_NOT_ENOUGH_MEMORY;
+ }
+
schema_list_item->obj = cur;
- DLIST_ADD_END(schema_list, schema_list_item, struct schema_list);
+ DLIST_ADD_END(schema_list, schema_list_item);
}
/* resolve objects until all are resolved and in local schema */
pass_no = 1;
+ working_schema = initial_schema;
while (schema_list) {
uint32_t converted_obj_count = 0;
uint32_t failed_obj_count = 0;
- TALLOC_CTX *tmp_ctx = talloc_new(mem_ctx);
- W_ERROR_HAVE_NO_MEMORY(tmp_ctx);
- for (schema_list_item = schema_list; schema_list_item; schema_list_item=schema_list_next_item) {
+ if (resulting_schema != working_schema) {
+ /*
+ * If the selfmade schema is not the schema used to
+ * translate and validate replicated object,
+ * Which means that we are using the bootstrap schema
+ * Then we add attributes and classes that were already
+ * translated to the working schema, the idea is that
+ * we might need to add new attributes and classes
+ * to be able to translate critical replicated objects
+ * and without that we wouldn't be able to translate them
+ */
+ werr = dsdb_repl_merge_working_schema(ldb,
+ working_schema,
+ resulting_schema);
+ if (!W_ERROR_IS_OK(werr)) {
+ talloc_free(frame);
+ return werr;
+ }
+ }
+
+ for (schema_list_item = schema_list;
+ schema_list_item;
+ schema_list_item=schema_list_next_item) {
struct dsdb_extended_replicated_object object;
cur = schema_list_item->obj;
- /* Save the next item, now we have saved out
+ /*
+ * Save the next item, now we have saved out
* the current one, so we can DLIST_REMOVE it
- * safely */
+ * safely
+ */
schema_list_next_item = schema_list_item->next;
/*
* schema we have so far. It's ok if we fail to convert
* an object. We should convert more objects on next pass.
*/
- werr = dsdb_convert_object_ex(ldb, working_schema, pfm_remote,
- cur, gensec_skey,
+ werr = dsdb_convert_object_ex(ldb, working_schema,
+ NULL,
+ pfm_remote,
+ cur, &empty_key,
ignore_attids,
0,
- tmp_ctx, &object);
+ schema_list_item, &object);
if (!W_ERROR_IS_OK(werr)) {
- DEBUG(4,("debug: Failed to convert schema object %s into ldb msg, will try during next loop\n",
- cur->object.identifier->dn));
+ DEBUG(4,("debug: Failed to convert schema "
+ "object %s into ldb msg, "
+ "will try during next loop\n",
+ cur->object.identifier->dn));
failed_obj_count++;
} else {
* Convert the schema from ldb_message format
* (OIDs as OID strings) into schema, using
* the remote prefixMap
+ *
+ * It's not likely, but possible to get the
+ * same object twice and we should keep
+ * the last instance.
*/
- werr = dsdb_schema_set_el_from_ldb_msg(ldb,
- working_schema,
- object.msg);
+ werr = dsdb_schema_set_el_from_ldb_msg_dups(ldb,
+ resulting_schema,
+ object.msg,
+ true);
if (!W_ERROR_IS_OK(werr)) {
- DEBUG(4,("debug: failed to convert object %s into a schema element, will try during next loop: %s\n",
+ DEBUG(4,("debug: failed to convert "
+ "object %s into a schema element, "
+ "will try during next loop: %s\n",
ldb_dn_get_linearized(object.msg->dn),
win_errstr(werr)));
failed_obj_count++;
} else {
+ DEBUG(8,("Converted object %s into a schema element\n",
+ ldb_dn_get_linearized(object.msg->dn)));
DLIST_REMOVE(schema_list, schema_list_item);
- talloc_free(schema_list_item);
+ TALLOC_FREE(schema_list_item);
converted_obj_count++;
}
}
}
- talloc_free(tmp_ctx);
- DEBUG(4,("Schema load pass %d: %d/%d of %d objects left to be converted.\n",
- pass_no, failed_obj_count, converted_obj_count, object_count));
- pass_no++;
+ DEBUG(4,("Schema load pass %d: converted %d, %d of %d objects left to be converted.\n",
+ pass_no, converted_obj_count, failed_obj_count, object_count));
/* check if we converted any objects in this pass */
if (converted_obj_count == 0) {
- DEBUG(0,("Can't continue Schema load: didn't manage to convert any objects: all %d remaining of %d objects failed to convert\n", failed_obj_count, object_count));
+ DEBUG(0,("Can't continue Schema load: "
+ "didn't manage to convert any objects: "
+ "all %d remaining of %d objects "
+ "failed to convert\n",
+ failed_obj_count, object_count));
+ talloc_free(frame);
return WERR_INTERNAL_ERROR;
}
- /* rebuild indexes */
- ret = dsdb_setup_sorted_accessors(ldb, working_schema);
- if (LDB_SUCCESS != ret) {
- DEBUG(0,("Failed to create schema-cache indexes!\n"));
- return WERR_INTERNAL_ERROR;
+ /*
+ * Don't try to load the schema if there is missing object
+ * _and_ we are on the first pass as some critical objects
+ * might be missing.
+ */
+ if (failed_obj_count == 0 || pass_no > cycle_before_switching) {
+ /* prepare for another cycle */
+ working_schema = resulting_schema;
+
+ ret = dsdb_setup_sorted_accessors(ldb, working_schema);
+ if (LDB_SUCCESS != ret) {
+ DEBUG(0,("Failed to create schema-cache indexes!\n"));
+ talloc_free(frame);
+ return WERR_INTERNAL_ERROR;
+ }
}
- };
+ pass_no++;
+ }
+
+ talloc_free(frame);
+ return WERR_OK;
+}
+
+/**
+ * Multi-pass working schema creation
+ * Function will:
+ * - shallow copy initial schema supplied
+ * - create a working schema in multiple passes
+ * until all objects are resolved
+ * Working schema is a schema with Attributes, Classes
+ * and indexes, but w/o subClassOf, possibleSupperiors etc.
+ * It is to be used just us cache for converting attribute values.
+ */
+WERROR dsdb_repl_make_working_schema(struct ldb_context *ldb,
+ const struct dsdb_schema *initial_schema,
+ const struct drsuapi_DsReplicaOIDMapping_Ctr *mapping_ctr,
+ uint32_t object_count,
+ const struct drsuapi_DsReplicaObjectListItemEx *first_object,
+ const DATA_BLOB *gensec_skey,
+ TALLOC_CTX *mem_ctx,
+ struct dsdb_schema **_schema_out)
+{
+ WERROR werr;
+ struct dsdb_schema_prefixmap *pfm_remote;
+ uint32_t r;
+ struct dsdb_schema *working_schema;
+
+ /* make a copy of the iniatial_scheam so we don't mess with it */
+ working_schema = dsdb_schema_copy_shallow(mem_ctx, ldb, initial_schema);
+ if (!working_schema) {
+ DEBUG(0,(__location__ ": schema copy failed!\n"));
+ return WERR_NOT_ENOUGH_MEMORY;
+ }
+ working_schema->resolving_in_progress = true;
+
+ /* we are going to need remote prefixMap for decoding */
+ werr = dsdb_schema_pfm_from_drsuapi_pfm(mapping_ctr, true,
+ working_schema, &pfm_remote, NULL);
+ if (!W_ERROR_IS_OK(werr)) {
+ DEBUG(0,(__location__ ": Failed to decode remote prefixMap: %s\n",
+ win_errstr(werr)));
+ talloc_free(working_schema);
+ return werr;
+ }
+
+ for (r=0; r < pfm_remote->length; r++) {
+ const struct dsdb_schema_prefixmap_oid *rm = &pfm_remote->prefixes[r];
+ bool found_oid = false;
+ uint32_t l;
+
+ for (l=0; l < working_schema->prefixmap->length; l++) {
+ const struct dsdb_schema_prefixmap_oid *lm = &working_schema->prefixmap->prefixes[l];
+ int cmp;
+
+ cmp = data_blob_cmp(&rm->bin_oid, &lm->bin_oid);
+ if (cmp == 0) {
+ found_oid = true;
+ break;
+ }
+ }
+
+ if (found_oid) {
+ continue;
+ }
+
+ /*
+ * We prefer the same is as we got from the remote peer
+ * if there's no conflict.
+ */
+ werr = dsdb_schema_pfm_add_entry(working_schema->prefixmap,
+ rm->bin_oid, &rm->id, NULL);
+ if (!W_ERROR_IS_OK(werr)) {
+ DEBUG(0,(__location__ ": Failed to merge remote prefixMap: %s",
+ win_errstr(werr)));
+ talloc_free(working_schema);
+ return werr;
+ }
+ }
+
+ werr = dsdb_repl_resolve_working_schema(ldb,
+ pfm_remote,
+ 0, /* cycle_before_switching */
+ working_schema,
+ working_schema,
+ object_count,
+ first_object);
+ if (!W_ERROR_IS_OK(werr)) {
+ DEBUG(0, ("%s: dsdb_repl_resolve_working_schema() failed: %s",
+ __location__, win_errstr(werr)));
+ talloc_free(working_schema);
+ return werr;
+ }
+
+ working_schema->resolving_in_progress = false;
*_schema_out = working_schema;
return false;
}
+static WERROR dsdb_verify_repl_meta_data(const struct drsuapi_DsReplicaMetaData *d,
+ const struct GUID *dst_invocation_id,
+ const struct GUID *src_invocation_id,
+ uint64_t src_last_hwm,
+ const * const char *error_hint)
+{
+ bool match;
+
+ *error_hint = NULL;
+
+ match = GUID_all_zero(&d->originating_invocation_id);
+ if (match) {
+ *error_hint = "got zero invocationID";
+ return WERR_DS_SRC_GUID_MISMATCH;
+ }
+
+ // TODO detect restored backup on source or destination dsa
+ // ERROR_DS_DRA_SOURCE_REINSTALLED
+ // ERROR_DS_EPOCH_MISMATCH
+ // ERROR_DS_SRC_GUID_MISMATCH
+ // ERROR_DS_OUT_OF_VERSION_STORE
+ // ERROR_DS_DIFFERENT_REPL_EPOCHS
+ // ERROR_DS_DRS_EXTENSIONS_CHANGED
+ // ERROR_DS_DUPLICATE_ID_FOUND
+ // ERROR_DS_DRA_OUT_SCHEDULE_WINDOW
+ // ERROR_DS_REPL_LIFETIME_EXCEEDED
+ // ERROR_DS_NO_NTDSA_OBJECT
+ // ERROR_DS_DRA_SOURCE_REINSTALLED
+ // ERROR_DS_DRA_INCONSISTENT_DIT
+
+ if (dst_invocation_id != NULL) {
+ match = GUID_equal(&d->originating_invocation_id,
+ dst_invocation_id);
+ if (match) {
+ *error_hint = "got destination(local) invocationID";
+ return WERR_DS_DRA_INCONSISTENT_DIT;
+ }
+ }
+
+ if (src_invocation_id != NULL) {
+ match = GUID_equal(&d->originating_invocation_id,
+ src_invocation_id);
+ if (match && d->originating_usn < src_last_hwm) {
+ *error_hint = "got old source(remote) dsa stamp";
+ return WERR_DS_DRA_SOURCE_REINSTALLED;
+ }
+ }
+
+ return WERR_OK;
+}
+
WERROR dsdb_convert_object_ex(struct ldb_context *ldb,
const struct dsdb_schema *schema,
+ struct ldb_dn *partition_dn,
const struct dsdb_schema_prefixmap *pfm_remote,
const struct drsuapi_DsReplicaObjectListItemEx *in,
const DATA_BLOB *gensec_skey,
TALLOC_CTX *mem_ctx,
struct dsdb_extended_replicated_object *out)
{
- NTSTATUS nt_status;
- WERROR status;
+ WERROR status = WERR_OK;
uint32_t i;
struct ldb_message *msg;
struct replPropertyMetaDataBlob *md;
int instanceType;
- struct ldb_val guid_value;
- struct ldb_val parent_guid_value;
+ struct ldb_message_element *instanceType_e = NULL;
NTTIME whenChanged = 0;
time_t whenChanged_t;
const char *whenChanged_s;
- const char *rdn_name = NULL;
- const struct ldb_val *rdn_value = NULL;
- const struct dsdb_attribute *rdn_attr = NULL;
- uint32_t rdn_attid;
- struct drsuapi_DsReplicaAttribute *name_a = NULL;
- struct drsuapi_DsReplicaMetaData *name_d = NULL;
- struct replPropertyMetaData1 *rdn_m = NULL;
struct dom_sid *sid = NULL;
uint32_t rid = 0;
uint32_t attr_count;
- int ret;
if (!in->object.identifier) {
return WERR_FOOBAR;
msg->dn = ldb_dn_new(msg, ldb, in->object.identifier->dn);
W_ERROR_HAVE_NO_MEMORY(msg->dn);
- rdn_name = ldb_dn_get_rdn_name(msg->dn);
- rdn_attr = dsdb_attribute_by_lDAPDisplayName(schema, rdn_name);
- if (!rdn_attr) {
- return WERR_FOOBAR;
- }
- rdn_attid = rdn_attr->attributeID_id;
- rdn_value = ldb_dn_get_rdn_val(msg->dn);
-
msg->num_elements = in->object.attribute_ctr.num_attributes;
msg->elements = talloc_array(msg, struct ldb_message_element,
msg->num_elements);
md->ctr.ctr1.reserved = 0;
md->ctr.ctr1.array = talloc_array(mem_ctx,
struct replPropertyMetaData1,
- md->ctr.ctr1.count + 1); /* +1 because of the RDN attribute */
+ md->ctr.ctr1.count);
W_ERROR_HAVE_NO_MEMORY(md->ctr.ctr1.array);
for (i=0, attr_count=0; i < in->meta_data_ctr->count; i++, attr_count++) {
struct replPropertyMetaData1 *m;
struct ldb_message_element *e;
uint32_t j;
+ const char *error_hint = NULL;
a = &in->object.attribute_ctr.attributes[i];
d = &in->meta_data_ctr->meta_data[i];
continue;
}
+ status = dsdb_verify_repl_meta_data(d,
+ dst_invocation_id,
+ src_invocation_id,
+ src_last_hwm,
+ &error_hint);
+ if (!W_ERROR_IS_OK(werr)) {
+ DEBUG(0, ("Refusing replication of object on attribute %d of %s: %s - %s\n",
+ a->attid,
+ ldb_dn_get_linearized(msg->dn),
+ win_errstr(status),
+ error_hint));
+ return status;
+ }
+
+ if (a->attid == DRSUAPI_ATTID_instanceType) {
+ if (instanceType_e != NULL) {
+ return WERR_FOOBAR;
+ }
+ instanceType_e = e;
+ }
+
for (j=0; j<a->value_ctr.num_values; j++) {
- status = drsuapi_decrypt_attribute(a->value_ctr.values[j].blob, gensec_skey, rid, a);
- W_ERROR_NOT_OK_RETURN(status);
+ status = drsuapi_decrypt_attribute(a->value_ctr.values[j].blob,
+ gensec_skey, rid,
+ dsdb_repl_flags, a);
+ if (!W_ERROR_IS_OK(status)) {
+ break;
+ }
+ }
+ if (W_ERROR_EQUAL(status, WERR_TOO_MANY_SECRETS)) {
+ WERROR get_name_status = dsdb_attribute_drsuapi_to_ldb(ldb, schema, pfm_remote,
+ a, msg->elements, e, NULL);
+ if (W_ERROR_IS_OK(get_name_status)) {
+ DEBUG(0, ("Unxpectedly got secret value %s on %s from DRS server\n",
+ e->name, ldb_dn_get_linearized(msg->dn)));
+ } else {
+ DEBUG(0, ("Unxpectedly got secret value on %s from DRS server",
+ ldb_dn_get_linearized(msg->dn)));
+ }
+ } else if (!W_ERROR_IS_OK(status)) {
+ return status;
}
+ /*
+ * This function also fills in the local attid value,
+ * based on comparing the remote and local prefixMap
+ * tables. If we don't convert the value, then we can
+ * have invalid values in the replPropertyMetaData we
+ * store on disk, as the prefixMap is per host, not
+ * per-domain. This may be why Microsoft added the
+ * msDS-IntID feature, however this is not used for
+ * extra attributes in the schema partition itself.
+ */
status = dsdb_attribute_drsuapi_to_ldb(ldb, schema, pfm_remote,
- a, msg->elements, e);
+ a, msg->elements, e,
+ &m->attid);
W_ERROR_NOT_OK_RETURN(status);
- m->attid = a->attid;
m->version = d->version;
m->originating_change_time = d->originating_change_time;
m->originating_invocation_id = d->originating_invocation_id;
m->originating_usn = d->originating_usn;
m->local_usn = 0;
+ if (a->attid == DRSUAPI_ATTID_name) {
+ const struct ldb_val *rdn_val = ldb_dn_get_rdn_val(msg->dn);
+ if (rdn_val == NULL) {
+ DEBUG(0, ("Unxpectedly unable to get RDN from %s for validation",
+ ldb_dn_get_linearized(msg->dn)));
+ return WERR_FOOBAR;
+ }
+ if (e->num_values != 1) {
+ DEBUG(0, ("Unxpectedly got wrong number of attribute values (got %u, expected 1) when checking RDN against name of %s",
+ e->num_values,
+ ldb_dn_get_linearized(msg->dn)));
+ return WERR_FOOBAR;
+ }
+ if (data_blob_cmp(rdn_val,
+ &e->values[0]) != 0) {
+ DEBUG(0, ("Unxpectedly got mismatching RDN values when checking RDN against name of %s",
+ ldb_dn_get_linearized(msg->dn)));
+ return WERR_FOOBAR;
+ }
+ }
if (d->originating_change_time > whenChanged) {
whenChanged = d->originating_change_time;
}
- if (a->attid == DRSUAPI_ATTID_name) {
- name_a = a;
- name_d = d;
- }
}
msg->num_elements = attr_count;
md->ctr.ctr1.count = attr_count;
- if (name_a) {
- rdn_m = &md->ctr.ctr1.array[md->ctr.ctr1.count];
- }
- if (rdn_m) {
- struct ldb_message_element *el;
- el = ldb_msg_find_element(msg, rdn_attr->lDAPDisplayName);
- if (!el) {
- ret = ldb_msg_add_value(msg, rdn_attr->lDAPDisplayName, rdn_value, NULL);
- if (ret != LDB_SUCCESS) {
- return WERR_FOOBAR;
- }
- } else {
- if (el->num_values != 1) {
- DEBUG(0,(__location__ ": Unexpected num_values=%u\n",
- el->num_values));
- return WERR_FOOBAR;
- }
- if (!ldb_val_equal_exact(&el->values[0], rdn_value)) {
- DEBUG(0,(__location__ ": RDN value changed? '%*.*s' '%*.*s'\n",
- (int)el->values[0].length, (int)el->values[0].length, el->values[0].data,
- (int)rdn_value->length, (int)rdn_value->length, rdn_value->data));
- return WERR_FOOBAR;
- }
- }
+ if (instanceType_e == NULL) {
+ return WERR_FOOBAR;
+ }
- rdn_m->attid = rdn_attid;
- rdn_m->version = name_d->version;
- rdn_m->originating_change_time = name_d->originating_change_time;
- rdn_m->originating_invocation_id = name_d->originating_invocation_id;
- rdn_m->originating_usn = name_d->originating_usn;
- rdn_m->local_usn = 0;
- md->ctr.ctr1.count++;
+ instanceType = ldb_msg_find_attr_as_int(msg, "instanceType", 0);
+ if ((instanceType & INSTANCE_TYPE_IS_NC_HEAD)
+ && partition_dn != NULL) {
+ int partition_dn_cmp = ldb_dn_compare(partition_dn, msg->dn);
+ if (partition_dn_cmp != 0) {
+ DEBUG(4, ("Remote server advised us of a new partition %s while processing %s, ignoring\n",
+ ldb_dn_get_linearized(msg->dn),
+ ldb_dn_get_linearized(partition_dn)));
+ return WERR_DS_ADD_REPLICA_INHIBITED;
+ }
}
- instanceType = ldb_msg_find_attr_as_int(msg, "instanceType", 0);
if (dsdb_repl_flags & DSDB_REPL_FLAG_PARTIAL_REPLICA) {
/* the instanceType type for partial_replica
replication is sent via DRS with TYPE_WRITE set, but
must be used on the client with TYPE_WRITE removed
*/
if (instanceType & INSTANCE_TYPE_WRITE) {
+ /*
+ * Make sure we do not change the order
+ * of msg->elements!
+ *
+ * That's why we use
+ * instanceType_e->num_values = 0
+ * instead of
+ * ldb_msg_remove_attr(msg, "instanceType");
+ */
+ struct ldb_message_element *e;
+
+ e = ldb_msg_find_element(msg, "instanceType");
+ if (e != instanceType_e) {
+ DEBUG(0,("instanceType_e[%p] changed to e[%p]\n",
+ instanceType_e, e));
+ return WERR_FOOBAR;
+ }
+
+ instanceType_e->num_values = 0;
+
instanceType &= ~INSTANCE_TYPE_WRITE;
- ldb_msg_remove_attr(msg, "instanceType");
if (ldb_msg_add_fmt(msg, "instanceType", "%d", instanceType) != LDB_SUCCESS) {
return WERR_INTERNAL_ERROR;
}
}
} else {
if (!(instanceType & INSTANCE_TYPE_WRITE)) {
- DEBUG(0, ("Refusing to replicate %s from a read-only repilca into a read-write replica!\n",
- ldb_dn_get_linearized(msg->dn)));
+ DBG_ERR("Refusing to replicate %s from a read-only "
+ "replica into a read-write replica!\n",
+ ldb_dn_get_linearized(msg->dn));
return WERR_DS_DRA_SOURCE_IS_PARTIAL_REPLICA;
}
}
whenChanged_s = ldb_timestring(msg, whenChanged_t);
W_ERROR_HAVE_NO_MEMORY(whenChanged_s);
- nt_status = GUID_to_ndr_blob(&in->object.identifier->guid, msg, &guid_value);
- if (!NT_STATUS_IS_OK(nt_status)) {
- return ntstatus_to_werror(nt_status);
- }
+ out->object_guid = in->object.identifier->guid;
- if (in->parent_object_guid) {
- nt_status = GUID_to_ndr_blob(in->parent_object_guid, msg, &parent_guid_value);
- if (!NT_STATUS_IS_OK(nt_status)) {
- return ntstatus_to_werror(nt_status);
- }
+ if (in->parent_object_guid == NULL) {
+ out->parent_guid = NULL;
} else {
- parent_guid_value = data_blob_null;
+ out->parent_guid = talloc(mem_ctx, struct GUID);
+ W_ERROR_HAVE_NO_MEMORY(out->parent_guid);
+ *out->parent_guid = *in->parent_object_guid;
}
out->msg = msg;
- out->guid_value = guid_value;
- out->parent_guid_value = parent_guid_value;
out->when_changed = whenChanged_s;
out->meta_data = md;
return WERR_OK;
WERROR dsdb_replicated_objects_convert(struct ldb_context *ldb,
const struct dsdb_schema *schema,
- const char *partition_dn_str,
+ struct ldb_dn *partition_dn,
const struct drsuapi_DsReplicaOIDMapping_Ctr *mapping_ctr,
uint32_t object_count,
const struct drsuapi_DsReplicaObjectListItemEx *first_object,
struct dsdb_extended_replicated_objects **objects)
{
WERROR status;
- struct ldb_dn *partition_dn;
struct dsdb_schema_prefixmap *pfm_remote;
struct dsdb_extended_replicated_objects *out;
const struct drsuapi_DsReplicaObjectListItemEx *cur;
+ struct dsdb_syntax_ctx syntax_ctx;
uint32_t i;
out = talloc_zero(mem_ctx, struct dsdb_extended_replicated_objects);
schema = talloc_reference(out, schema);
W_ERROR_HAVE_NO_MEMORY(schema);
- partition_dn = ldb_dn_new(out, ldb, partition_dn_str);
- W_ERROR_HAVE_NO_MEMORY_AND_FREE(partition_dn, out);
-
status = dsdb_schema_pfm_from_drsuapi_pfm(mapping_ctr, true,
out, &pfm_remote, NULL);
if (!W_ERROR_IS_OK(status)) {
- DEBUG(0,(__location__ ": Failed to decode remote prefixMap: %s",
+ DEBUG(0,(__location__ ": Failed to decode remote prefixMap: %s\n",
win_errstr(status)));
talloc_free(out);
return status;
}
+ /* use default syntax conversion context */
+ dsdb_syntax_ctx_init(&syntax_ctx, ldb, schema);
+ syntax_ctx.pfm_remote = pfm_remote;
+
if (ldb_dn_compare(partition_dn, ldb_get_schema_basedn(ldb)) != 0) {
/*
* check for schema changes in case
*/
status = dsdb_schema_info_cmp(schema, mapping_ctr);
if (!W_ERROR_IS_OK(status)) {
- DEBUG(1,("Remote schema has changed while replicating %s\n",
- partition_dn_str));
+ DEBUG(4,("Can't replicate %s because remote schema has changed since we last replicated the schema\n",
+ ldb_dn_get_linearized(partition_dn)));
talloc_free(out);
return status;
}
out->source_dsa = source_dsa;
out->uptodateness_vector= uptodateness_vector;
- out->num_objects = object_count;
+ out->num_objects = 0;
out->objects = talloc_array(out,
struct dsdb_extended_replicated_object,
- out->num_objects);
+ object_count);
W_ERROR_HAVE_NO_MEMORY_AND_FREE(out->objects, out);
- /* pass the linked attributes down to the repl_meta_data
- module */
- out->linked_attributes_count = linked_attributes_count;
- out->linked_attributes = linked_attributes;
-
for (i=0, cur = first_object; cur; cur = cur->next_object, i++) {
- if (i == out->num_objects) {
+ if (i == object_count) {
talloc_free(out);
return WERR_FOOBAR;
}
- status = dsdb_convert_object_ex(ldb, schema, pfm_remote,
+ status = dsdb_convert_object_ex(ldb, schema, out->partition_dn,
+ pfm_remote,
cur, gensec_skey,
NULL,
dsdb_repl_flags,
- out->objects, &out->objects[i]);
+ out->objects,
+ &out->objects[out->num_objects]);
+
+ /*
+ * Check to see if we have been advised of a
+ * subdomain or new application partition. We don't
+ * want to start on that here, instead the caller
+ * should consider if it would like to replicate it
+ * based on the cross-ref object.
+ */
+ if (W_ERROR_EQUAL(status, WERR_DS_ADD_REPLICA_INHIBITED)) {
+ struct GUID_txt_buf guid_str;
+ DBG_ERR("Ignoring object outside partition %s %s: %s\n",
+ GUID_buf_string(&cur->object.identifier->guid,
+ &guid_str),
+ cur->object.identifier->dn,
+ win_errstr(status));
+ continue;
+ }
+
if (!W_ERROR_IS_OK(status)) {
talloc_free(out);
DEBUG(0,("Failed to convert object %s: %s\n",
win_errstr(status)));
return status;
}
+
+ /* Assuming we didn't skip or error, increment the number of objects */
+ out->num_objects++;
}
- if (i != out->num_objects) {
+ out->objects = talloc_realloc(out, out->objects,
+ struct dsdb_extended_replicated_object,
+ out->num_objects);
+ if (out->num_objects != 0 && out->objects == NULL) {
talloc_free(out);
return WERR_FOOBAR;
}
+ if (i != object_count) {
+ talloc_free(out);
+ return WERR_FOOBAR;
+ }
+
+ out->linked_attributes = talloc_array(out,
+ struct drsuapi_DsReplicaLinkedAttribute,
+ linked_attributes_count);
+ W_ERROR_HAVE_NO_MEMORY_AND_FREE(out->linked_attributes, out);
+
+ for (i=0; i < linked_attributes_count; i++) {
+ const struct drsuapi_DsReplicaLinkedAttribute *ra = &linked_attributes[i];
+ struct drsuapi_DsReplicaLinkedAttribute *la = &out->linked_attributes[i];
+
+ if (ra->identifier == NULL) {
+ talloc_free(out);
+ return WERR_BAD_NET_RESP;
+ }
+
+ *la = *ra;
+
+ la->identifier = talloc_zero(out->linked_attributes,
+ struct drsuapi_DsReplicaObjectIdentifier);
+ W_ERROR_HAVE_NO_MEMORY_AND_FREE(la->identifier, out);
+
+ /*
+ * We typically only get the guid filled
+ * and the repl_meta_data module only cares abouf
+ * the guid.
+ */
+ la->identifier->guid = ra->identifier->guid;
+
+ if (ra->value.blob != NULL) {
+ la->value.blob = talloc_zero(out->linked_attributes,
+ DATA_BLOB);
+ W_ERROR_HAVE_NO_MEMORY_AND_FREE(la->value.blob, out);
+
+ if (ra->value.blob->length != 0) {
+ *la->value.blob = data_blob_dup_talloc(la->value.blob,
+ *ra->value.blob);
+ W_ERROR_HAVE_NO_MEMORY_AND_FREE(la->value.blob->data, out);
+ }
+ }
+
+ status = dsdb_attribute_drsuapi_remote_to_local(&syntax_ctx,
+ ra->attid,
+ &la->attid,
+ NULL);
+ if (!W_ERROR_IS_OK(status)) {
+ DEBUG(0,(__location__": linked_attribute[%u] attid 0x%08X not found: %s\n",
+ i, ra->attid, win_errstr(status)));
+ return status;
+ }
+
+ status = dsdb_verify_repl_meta_data(&la->meta_data,
+ dst_invocation_id,
+ src_invocation_id,
+ src_last_hwm,
+ &error_hint);
+ if (!W_ERROR_IS_OK(werr)) {
+ DEBUG(0, ("Refusing replication of linked on attribute %d of <GUID=%s>: %s - %s\n",
+ la->attid,
+ GUID_string(out, &la->identifier->guid),,
+ win_errstr(status),
+ error_hint));
+ return status;
+ }
+ }
+
+ out->linked_attributes_count = linked_attributes_count;
/* free pfm_remote, we won't need it anymore */
talloc_free(pfm_remote);
WERROR werr;
struct ldb_result *ext_res;
struct dsdb_schema *cur_schema = NULL;
+ struct dsdb_schema *new_schema = NULL;
int ret;
uint64_t seq_num1, seq_num2;
+ bool used_global_schema = false;
- /* TODO: handle linked attributes */
+ TALLOC_CTX *tmp_ctx = talloc_new(objects);
+ if (!tmp_ctx) {
+ DEBUG(0,("Failed to start talloc\n"));
+ return WERR_NOT_ENOUGH_MEMORY;
+ }
/* wrap the extended operation in a transaction
See [MS-DRSR] 3.3.2 Transactions
*/
ret = ldb_transaction_start(ldb);
if (ret != LDB_SUCCESS) {
- DEBUG(0,(__location__ " Failed to start transaction\n"));
+ DEBUG(0,(__location__ " Failed to start transaction: %s\n",
+ ldb_errstring(ldb)));
return WERR_FOOBAR;
}
if (ret != LDB_SUCCESS) {
DEBUG(0,(__location__ " Failed to load partition uSN\n"));
ldb_transaction_cancel(ldb);
+ TALLOC_FREE(tmp_ctx);
return WERR_FOOBAR;
}
*/
if (working_schema) {
/* store current schema so we can fall back in case of failure */
- cur_schema = dsdb_get_schema(ldb, working_schema);
+ cur_schema = dsdb_get_schema(ldb, tmp_ctx);
+ used_global_schema = dsdb_uses_global_schema(ldb);
- ret = dsdb_reference_schema(ldb, working_schema, false);
+ ret = dsdb_reference_schema(ldb, working_schema, SCHEMA_MEMORY_ONLY);
if (ret != LDB_SUCCESS) {
DEBUG(0,(__location__ "Failed to reference working schema - %s\n",
ldb_strerror(ret)));
/* TODO: Map LDB Error to NTSTATUS? */
ldb_transaction_cancel(ldb);
+ TALLOC_FREE(tmp_ctx);
return WERR_INTERNAL_ERROR;
}
}
ret = ldb_extended(ldb, DSDB_EXTENDED_REPLICATED_OBJECTS_OID, objects, &ext_res);
if (ret != LDB_SUCCESS) {
/* restore previous schema */
- if (cur_schema ) {
- dsdb_reference_schema(ldb, cur_schema, false);
- dsdb_make_schema_global(ldb, cur_schema);
+ if (used_global_schema) {
+ dsdb_set_global_schema(ldb);
+ } else if (cur_schema) {
+ dsdb_reference_schema(ldb, cur_schema, SCHEMA_MEMORY_ONLY);
}
- DEBUG(0,("Failed to apply records: %s: %s\n",
- ldb_errstring(ldb), ldb_strerror(ret)));
+ if (W_ERROR_EQUAL(objects->error, WERR_DS_DRA_RECYCLED_TARGET)) {
+ DEBUG(3,("Missing target while attempting to apply records: %s\n",
+ ldb_errstring(ldb)));
+ } else if (W_ERROR_EQUAL(objects->error, WERR_DS_DRA_MISSING_PARENT)) {
+ DEBUG(3,("Missing parent while attempting to apply records: %s\n",
+ ldb_errstring(ldb)));
+ } else {
+ DEBUG(1,("Failed to apply records: %s: %s\n",
+ ldb_errstring(ldb), ldb_strerror(ret)));
+ }
ldb_transaction_cancel(ldb);
+ TALLOC_FREE(tmp_ctx);
+
+ if (!W_ERROR_IS_OK(objects->error)) {
+ return objects->error;
+ }
return WERR_FOOBAR;
}
talloc_free(ext_res);
- /* Save our updated prefixMap */
+ /* Save our updated prefixMap and check the schema is good. */
if (working_schema) {
+ struct ldb_result *ext_res_2;
+
werr = dsdb_write_prefixes_from_schema_to_ldb(working_schema,
ldb,
working_schema);
if (!W_ERROR_IS_OK(werr)) {
/* restore previous schema */
- if (cur_schema ) {
- dsdb_reference_schema(ldb, cur_schema, false);
- dsdb_make_schema_global(ldb, cur_schema);
+ if (used_global_schema) {
+ dsdb_set_global_schema(ldb);
+ } else if (cur_schema ) {
+ dsdb_reference_schema(ldb,
+ cur_schema,
+ SCHEMA_MEMORY_ONLY);
}
DEBUG(0,("Failed to save updated prefixMap: %s\n",
win_errstr(werr)));
+ ldb_transaction_cancel(ldb);
+ TALLOC_FREE(tmp_ctx);
return werr;
}
+
+ /*
+ * Use dsdb_schema_from_db through dsdb extended to check we
+ * can load the schema currently sitting in the transaction.
+ * We need this check because someone might have written to
+ * the schema or prefixMap before we started the transaction,
+ * which may have caused corruption.
+ */
+ ret = ldb_extended(ldb, DSDB_EXTENDED_SCHEMA_LOAD,
+ NULL, &ext_res_2);
+
+ if (ret != LDB_SUCCESS) {
+ if (used_global_schema) {
+ dsdb_set_global_schema(ldb);
+ } else if (cur_schema) {
+ dsdb_reference_schema(ldb, cur_schema, SCHEMA_MEMORY_ONLY);
+ }
+ DEBUG(0,("Corrupt schema write attempt detected, "
+ "aborting schema modification operation.\n"
+ "This probably happened due to bad timing of "
+ "another schema edit: %s (%s)\n",
+ ldb_errstring(ldb),
+ ldb_strerror(ret)));
+ ldb_transaction_cancel(ldb);
+ TALLOC_FREE(tmp_ctx);
+ return WERR_FOOBAR;
+ }
}
ret = ldb_transaction_prepare_commit(ldb);
if (ret != LDB_SUCCESS) {
/* restore previous schema */
- if (cur_schema ) {
- dsdb_reference_schema(ldb, cur_schema, false);
- dsdb_make_schema_global(ldb, cur_schema);
+ if (used_global_schema) {
+ dsdb_set_global_schema(ldb);
+ } else if (cur_schema ) {
+ dsdb_reference_schema(ldb, cur_schema, SCHEMA_MEMORY_ONLY);
}
- DEBUG(0,(__location__ " Failed to prepare commit of transaction: %s\n",
- ldb_errstring(ldb)));
+ DBG_ERR(" Failed to prepare commit of transaction: %s (%s)\n",
+ ldb_errstring(ldb),
+ ldb_strerror(ret));
+ TALLOC_FREE(tmp_ctx);
return WERR_FOOBAR;
}
ret = dsdb_load_partition_usn(ldb, objects->partition_dn, &seq_num2, NULL);
if (ret != LDB_SUCCESS) {
/* restore previous schema */
- if (cur_schema ) {
- dsdb_reference_schema(ldb, cur_schema, false);
- dsdb_make_schema_global(ldb, cur_schema);
+ if (used_global_schema) {
+ dsdb_set_global_schema(ldb);
+ } else if (cur_schema ) {
+ dsdb_reference_schema(ldb, cur_schema, SCHEMA_MEMORY_ONLY);
}
DEBUG(0,(__location__ " Failed to load partition uSN\n"));
ldb_transaction_cancel(ldb);
+ TALLOC_FREE(tmp_ctx);
return WERR_FOOBAR;
}
- /* if this replication partner didn't need to be notified
- before this transaction then it still doesn't need to be
- notified, as the changes came from this server */
- if (seq_num2 > seq_num1 && seq_num1 <= *notify_uSN) {
- *notify_uSN = seq_num2;
- }
-
ret = ldb_transaction_commit(ldb);
if (ret != LDB_SUCCESS) {
/* restore previous schema */
- if (cur_schema ) {
- dsdb_reference_schema(ldb, cur_schema, false);
- dsdb_make_schema_global(ldb, cur_schema);
+ if (used_global_schema) {
+ dsdb_set_global_schema(ldb);
+ } else if (cur_schema ) {
+ dsdb_reference_schema(ldb, cur_schema, SCHEMA_MEMORY_ONLY);
}
DEBUG(0,(__location__ " Failed to commit transaction\n"));
+ TALLOC_FREE(tmp_ctx);
return WERR_FOOBAR;
}
+ if (seq_num1 > *notify_uSN) {
+ /*
+ * A notify was already required before
+ * the current transaction.
+ */
+ } else if (objects->originating_updates) {
+ /*
+ * Applying the replicated changes
+ * required originating updates,
+ * so a notify is required.
+ */
+ } else {
+ /*
+ * There's no need to notify the
+ * server about the change we just from it.
+ */
+ *notify_uSN = seq_num2;
+ }
+
/*
* Reset the Schema used by ldb. This will lead to
* a schema cache being refreshed from database.
*/
if (working_schema) {
- struct ldb_message *msg;
- struct ldb_request *req;
-
- /* Force a reload */
- working_schema->last_refresh = 0;
- cur_schema = dsdb_get_schema(ldb, NULL);
- /* TODO: What we do in case dsdb_get_schema() fail?
- * We can't fallback at this point anymore */
- if (cur_schema) {
- dsdb_make_schema_global(ldb, cur_schema);
- }
- msg = ldb_msg_new(ldb);
- if (msg == NULL) {
- return WERR_NOMEM;
- }
- msg->dn = ldb_dn_new(msg, ldb, "");
- if (msg->dn == NULL) {
- talloc_free(msg);
- return WERR_NOMEM;
- }
-
- ret = ldb_msg_add_string(msg, "schemaUpdateNow", "1");
- if (ret != LDB_SUCCESS) {
- talloc_free(msg);
+ /* Reload the schema */
+ new_schema = dsdb_get_schema(ldb, tmp_ctx);
+ /* TODO:
+ * If dsdb_get_schema() fails, we just fall back
+ * to what we had. However, the database is probably
+ * unable to operate for other users from this
+ * point... */
+ if (new_schema == NULL || new_schema == working_schema) {
+ DBG_ERR("Failed to re-load schema after commit of "
+ "transaction (working: %p/%"PRIu64", new: "
+ "%p/%"PRIu64")\n", new_schema,
+ new_schema != NULL ?
+ new_schema->metadata_usn : 0,
+ working_schema, working_schema->metadata_usn);
+ dsdb_reference_schema(ldb, cur_schema, SCHEMA_MEMORY_ONLY);
+ if (used_global_schema) {
+ dsdb_set_global_schema(ldb);
+ }
+ TALLOC_FREE(tmp_ctx);
return WERR_INTERNAL_ERROR;
- }
-
- ret = ldb_build_mod_req(&req, ldb, ldb,
- msg,
- LDB_SCOPE_BASE,
- NULL,
- ldb_op_default_callback,
- NULL);
-
- if (ret != LDB_SUCCESS) {
- talloc_free(msg);
- return WERR_DS_DRA_INTERNAL_ERROR;
- }
-
- ret = ldb_transaction_start(ldb);
- if (ret != LDB_SUCCESS) {
- talloc_free(msg);
- talloc_free(req);
- DEBUG(0, ("Autotransaction start failed\n"));
- return WERR_DS_DRA_INTERNAL_ERROR;
- }
-
- ret = ldb_request(ldb, req);
- if (ret == LDB_SUCCESS) {
- ret = ldb_wait(req->handle, LDB_WAIT_ALL);
- }
-
- if (ret == LDB_SUCCESS) {
- ret = ldb_transaction_commit(ldb);
- } else {
- DEBUG(0, ("Schema update now failed: %s\n", ldb_strerror(ret)));
- ldb_transaction_cancel(ldb);
- }
-
- talloc_free(msg);
- talloc_free(req);
- if (ret != LDB_SUCCESS) {
- DEBUG(0, ("Commit failed: %s\n", ldb_strerror(ret)));
- return WERR_DS_INTERNAL_FAILURE;
+ } else if (used_global_schema) {
+ dsdb_make_schema_global(ldb, new_schema);
}
}
objects->num_objects, objects->linked_attributes_count,
ldb_dn_get_linearized(objects->partition_dn)));
+ TALLOC_FREE(tmp_ctx);
return WERR_OK;
}
e = &msg->elements[i];
status = dsdb_attribute_drsuapi_to_ldb(ldb, schema, schema->prefixmap,
- a, msg->elements, e);
+ a, msg->elements, e, NULL);
W_ERROR_NOT_OK_RETURN(status);
}
objects = talloc_array(mem_ctx, struct ldb_message *,
num_objects);
if (objects == NULL) {
- status = WERR_NOMEM;
+ status = WERR_NOT_ENOUGH_MEMORY;
goto cancel;
}
struct drsuapi_DsReplicaObjectIdentifier2,
num_objects);
if (ids == NULL) {
- status = WERR_NOMEM;
+ status = WERR_NOT_ENOUGH_MEMORY;
goto cancel;
}