#include "lib/events/events.h"
#include "dsdb/samdb/samdb.h"
#include "../lib/util/dlinklist.h"
-#include "lib/ldb/include/ldb.h"
-#include "lib/ldb/include/ldb_errors.h"
+#include <ldb.h>
+#include <ldb_errors.h>
#include "librpc/ndr/libndr.h"
#include "librpc/gen_ndr/ndr_drsuapi.h"
#include "librpc/gen_ndr/ndr_drsblobs.h"
#include "librpc/gen_ndr/ndr_misc.h"
#include "system/time.h"
-#include "lib/ldb_wrap.h"
+#include "ldb_wrap.h"
#include "auth/auth.h"
+#include "auth/credentials/credentials.h"
#include "param/param.h"
#include "param/provision.h"
+#include "libcli/security/security.h"
+#include "dsdb/common/util.h"
/*
List of tasks vampire.py must perform:
- Write out the secrets database, using the code from libnet_Join
*/
-struct vampire_state {
+struct libnet_vampire_cb_state {
const char *netbios_name;
- struct libnet_JoinDomain *join;
+ const char *domain_name;
+ const char *realm;
struct cli_credentials *machine_account;
+
+ /* Schema loaded from local LDIF files */
+ struct dsdb_schema *provision_schema;
+
+ /* 1st pass, with some OIDs/attribute names/class names not
+ * converted, because we may not know them yet */
struct dsdb_schema *self_made_schema;
+
+ /* prefixMap in LDB format, from the remote DRS server */
+ DATA_BLOB prefixmap_blob;
const struct dsdb_schema *schema;
struct ldb_context *ldb;
struct tevent_context *event_ctx;
unsigned total_objects;
char *last_partition;
+ const char *server_dn_str;
};
-static NTSTATUS vampire_prepare_db(void *private_data,
- const struct libnet_BecomeDC_PrepareDB *p)
+/* initialise a state structure ready for replication of chunks */
+void *libnet_vampire_replicate_init(TALLOC_CTX *mem_ctx,
+ struct ldb_context *samdb,
+ struct loadparm_context *lp_ctx)
+{
+ struct libnet_vampire_cb_state *s = talloc_zero(mem_ctx, struct libnet_vampire_cb_state);
+ if (!s) {
+ return NULL;
+ }
+
+ s->ldb = samdb;
+ s->lp_ctx = lp_ctx;
+ s->provision_schema = dsdb_get_schema(s->ldb, s);
+ s->schema = s->provision_schema;
+ s->netbios_name = lpcfg_netbios_name(lp_ctx);
+ s->domain_name = lpcfg_workgroup(lp_ctx);
+ s->realm = lpcfg_realm(lp_ctx);
+
+ return s;
+}
+
+/* Caller is expected to keep supplied pointers around for the lifetime of the structure */
+void *libnet_vampire_cb_state_init(TALLOC_CTX *mem_ctx,
+ struct loadparm_context *lp_ctx, struct tevent_context *event_ctx,
+ const char *netbios_name, const char *domain_name, const char *realm,
+ const char *targetdir)
{
- struct vampire_state *s = talloc_get_type(private_data, struct vampire_state);
+ struct libnet_vampire_cb_state *s = talloc_zero(mem_ctx, struct libnet_vampire_cb_state);
+ if (!s) {
+ return NULL;
+ }
+
+ s->lp_ctx = lp_ctx;
+ s->event_ctx = event_ctx;
+ s->netbios_name = netbios_name;
+ s->domain_name = domain_name;
+ s->realm = realm;
+ s->targetdir = targetdir;
+ return s;
+}
+
+struct ldb_context *libnet_vampire_cb_ldb(struct libnet_vampire_cb_state *state)
+{
+ state = talloc_get_type_abort(state, struct libnet_vampire_cb_state);
+ return state->ldb;
+}
+
+struct loadparm_context *libnet_vampire_cb_lp_ctx(struct libnet_vampire_cb_state *state)
+{
+ state = talloc_get_type_abort(state, struct libnet_vampire_cb_state);
+ return state->lp_ctx;
+}
+
+NTSTATUS libnet_vampire_cb_prepare_db(void *private_data,
+ const struct libnet_BecomeDC_PrepareDB *p)
+{
+ struct libnet_vampire_cb_state *s = talloc_get_type(private_data, struct libnet_vampire_cb_state);
struct provision_settings settings;
struct provision_result result;
NTSTATUS status;
settings.config_dn_str = p->forest->config_dn_str;
settings.schema_dn_str = p->forest->schema_dn_str;
settings.netbios_name = p->dest_dsa->netbios_name;
- settings.realm = s->join->out.realm;
- settings.domain = s->join->out.domain_name;
+ settings.realm = s->realm;
+ settings.domain = s->domain_name;
settings.server_dn_str = p->dest_dsa->server_dn_str;
- settings.machine_password = generate_random_str(s, 16);
+ settings.machine_password = generate_random_password(s, 16, 255);
settings.targetdir = s->targetdir;
-
+ settings.use_ntvfs = true;
status = provision_bare(s, s->lp_ctx, &settings, &result);
if (!NT_STATUS_IS_OK(status)) {
return status;
}
- s->ldb = result.samdb;
- s->lp_ctx = result.lp_ctx;
+ s->ldb = talloc_steal(s, result.samdb);
+ s->lp_ctx = talloc_reparent(talloc_parent(result.lp_ctx), s, result.lp_ctx);
+ s->provision_schema = dsdb_get_schema(s->ldb, s);
+ s->server_dn_str = talloc_steal(s, p->dest_dsa->server_dn_str);
/* wrap the entire vapire operation in a transaction. This
isn't just cosmetic - we use this to ensure that linked
}
-static NTSTATUS vampire_check_options(void *private_data,
- const struct libnet_BecomeDC_CheckOptions *o)
+NTSTATUS libnet_vampire_cb_check_options(void *private_data,
+ const struct libnet_BecomeDC_CheckOptions *o)
{
- struct vampire_state *s = talloc_get_type(private_data, struct vampire_state);
+ struct libnet_vampire_cb_state *s = talloc_get_type(private_data, struct libnet_vampire_cb_state);
DEBUG(0,("Become DC [%s] of Domain[%s]/[%s]\n",
s->netbios_name,
return NT_STATUS_OK;
}
-static NTSTATUS vampire_apply_schema(struct vampire_state *s,
- const struct libnet_BecomeDC_StoreChunk *c)
+static NTSTATUS libnet_vampire_cb_apply_schema(struct libnet_vampire_cb_state *s,
+ const struct libnet_BecomeDC_StoreChunk *c)
{
WERROR status;
+ struct dsdb_schema_prefixmap *pfm_remote;
const struct drsuapi_DsReplicaOIDMapping_Ctr *mapping_ctr;
- uint32_t object_count;
+ struct dsdb_schema *provision_schema;
+ uint32_t object_count = 0;
struct drsuapi_DsReplicaObjectListItemEx *first_object;
- struct drsuapi_DsReplicaObjectListItemEx *cur;
uint32_t linked_attributes_count;
struct drsuapi_DsReplicaLinkedAttribute *linked_attributes;
const struct drsuapi_DsReplicaCursor2CtrEx *uptodateness_vector;
- struct dsdb_extended_replicated_objects *objs;
+ struct dsdb_extended_replicated_objects *schema_objs;
struct repsFromTo1 *s_dsa;
char *tmp_dns_name;
+ struct ldb_context *schema_ldb;
+ struct ldb_dn *partition_dn;
struct ldb_message *msg;
- struct ldb_val prefixMap_val;
struct ldb_message_element *prefixMap_el;
- struct ldb_val schemaInfo_val;
uint32_t i;
int ret;
bool ok;
- uint64_t seq_num;
+ uint64_t seq_num = 0;
+ uint32_t cycle_before_switching;
DEBUG(0,("Analyze and apply schema objects\n"));
default:
return NT_STATUS_INVALID_PARAMETER;
}
+ /* We must set these up to ensure the replMetaData is written
+ * correctly, before our NTDS Settings entry is replicated */
+ ok = samdb_set_ntds_invocation_id(s->ldb, &c->dest_dsa->invocation_id);
+ if (!ok) {
+ DEBUG(0,("Failed to set cached ntds invocationId\n"));
+ return NT_STATUS_FOOBAR;
+ }
+ ok = samdb_set_ntds_objectGUID(s->ldb, &c->dest_dsa->ntds_guid);
+ if (!ok) {
+ DEBUG(0,("Failed to set cached ntds objectGUID\n"));
+ return NT_STATUS_FOOBAR;
+ }
- s_dsa->replica_flags = DRSUAPI_DS_REPLICA_NEIGHBOUR_WRITEABLE
- | DRSUAPI_DS_REPLICA_NEIGHBOUR_SYNC_ON_STARTUP
- | DRSUAPI_DS_REPLICA_NEIGHBOUR_DO_SCHEDULED_SYNCS;
+ status = dsdb_schema_pfm_from_drsuapi_pfm(mapping_ctr, true,
+ s, &pfm_remote, NULL);
+ if (!W_ERROR_IS_OK(status)) {
+ DEBUG(0,(__location__ ": Failed to decode remote prefixMap: %s",
+ win_errstr(status)));
+ return werror_to_ntstatus(status);
+ }
+
+ s_dsa->replica_flags = DRSUAPI_DRS_WRIT_REP
+ | DRSUAPI_DRS_INIT_SYNC
+ | DRSUAPI_DRS_PER_SYNC;
memset(s_dsa->schedule, 0x11, sizeof(s_dsa->schedule));
tmp_dns_name = GUID_string(s_dsa->other_info, &s_dsa->source_dsa_obj_guid);
NT_STATUS_HAVE_NO_MEMORY(tmp_dns_name);
s_dsa->other_info->dns_name = tmp_dns_name;
- for (cur = first_object; cur; cur = cur->next_object) {
- bool is_attr = false;
- bool is_class = false;
-
- for (i=0; i < cur->object.attribute_ctr.num_attributes; i++) {
- struct drsuapi_DsReplicaAttribute *a;
- uint32_t j;
- const char *oid = NULL;
-
- a = &cur->object.attribute_ctr.attributes[i];
- status = dsdb_map_int2oid(s->self_made_schema, a->attid, s, &oid);
- if (!W_ERROR_IS_OK(status)) {
- return werror_to_ntstatus(status);
- }
-
- switch (a->attid) {
- case DRSUAPI_ATTRIBUTE_objectClass:
- for (j=0; j < a->value_ctr.num_values; j++) {
- uint32_t val = 0xFFFFFFFF;
-
- if (a->value_ctr.values[j].blob
- && a->value_ctr.values[j].blob->length == 4) {
- val = IVAL(a->value_ctr.values[j].blob->data,0);
- }
-
- if (val == DRSUAPI_OBJECTCLASS_attributeSchema) {
- is_attr = true;
- }
- if (val == DRSUAPI_OBJECTCLASS_classSchema) {
- is_class = true;
- }
- }
-
- break;
- default:
- break;
- }
- }
-
- if (is_attr) {
- struct dsdb_attribute *sa;
-
- sa = talloc_zero(s->self_made_schema, struct dsdb_attribute);
- NT_STATUS_HAVE_NO_MEMORY(sa);
-
- status = dsdb_attribute_from_drsuapi(s->ldb, s->self_made_schema, &cur->object, s, sa);
- if (!W_ERROR_IS_OK(status)) {
- return werror_to_ntstatus(status);
- }
+ if (s->self_made_schema == NULL) {
+ DEBUG(0,("libnet_vampire_cb_apply_schema: called with out self_made_schema\n"));
+ return NT_STATUS_INTERNAL_ERROR;
+ }
- DLIST_ADD_END(s->self_made_schema->attributes, sa, struct dsdb_attribute *);
+ schema_ldb = provision_get_schema(s, s->lp_ctx,
+ c->forest->schema_dn_str,
+ &s->prefixmap_blob);
+ if (!schema_ldb) {
+ DEBUG(0,("Failed to re-load from local provision using remote prefixMap. "
+ "Will continue with local prefixMap\n"));
+ provision_schema = dsdb_get_schema(s->ldb, s);
+ } else {
+ provision_schema = dsdb_get_schema(schema_ldb, s);
+ ret = dsdb_reference_schema(s->ldb, provision_schema, false);
+ if (ret != LDB_SUCCESS) {
+ DEBUG(0,("Failed to attach schema from local provision using remote prefixMap."));
+ return NT_STATUS_UNSUCCESSFUL;
}
+ talloc_free(schema_ldb);
+ }
- if (is_class) {
- struct dsdb_class *sc;
-
- sc = talloc_zero(s->self_made_schema, struct dsdb_class);
- NT_STATUS_HAVE_NO_MEMORY(sc);
-
- status = dsdb_class_from_drsuapi(s->self_made_schema, &cur->object, s, sc);
- if (!W_ERROR_IS_OK(status)) {
- return werror_to_ntstatus(status);
- }
+ cycle_before_switching = lpcfg_parm_long(s->lp_ctx, NULL,
+ "become dc",
+ "schema convert retrial", 1);
- DLIST_ADD_END(s->self_made_schema->classes, sc, struct dsdb_class *);
- }
+ status = dsdb_repl_resolve_working_schema(s->ldb,
+ pfm_remote,
+ cycle_before_switching,
+ provision_schema,
+ s->self_made_schema,
+ object_count,
+ first_object);
+ if (!W_ERROR_IS_OK(status)) {
+ DEBUG(0, ("%s: dsdb_repl_resolve_working_schema() failed: %s",
+ __location__, win_errstr(status)));
+ return werror_to_ntstatus(status);
}
- /* attach the schema to the ldb */
+ /* free temp objects for 1st conversion phase */
+ talloc_unlink(s, provision_schema);
+
+ /*
+ * attach the schema we just brought over DRS to the ldb,
+ * so we can use it in dsdb_convert_object_ex below
+ */
ret = dsdb_set_schema(s->ldb, s->self_made_schema);
if (ret != LDB_SUCCESS) {
+ DEBUG(0,("Failed to attach working schema from DRS.\n"));
return NT_STATUS_FOOBAR;
}
+
/* we don't want to access the self made schema anymore */
+ s->schema = s->self_made_schema;
s->self_made_schema = NULL;
- s->schema = dsdb_get_schema(s->ldb);
-
- status = dsdb_extended_replicated_objects_commit(s->ldb,
- c->partition->nc.dn,
- mapping_ctr,
- object_count,
- first_object,
- linked_attributes_count,
- linked_attributes,
- s_dsa,
- uptodateness_vector,
- c->gensec_skey,
- s, &objs, &seq_num);
+
+ partition_dn = ldb_dn_new(s, s->ldb, c->partition->nc.dn);
+ if (partition_dn == NULL) {
+ DEBUG(0,("Failed to parse partition DN from DRS.\n"));
+ return NT_STATUS_FOOBAR;
+ }
+
+ /* Now convert the schema elements again, using the schema we finalised, ready to actually import */
+ status = dsdb_replicated_objects_convert(s->ldb,
+ s->schema,
+ partition_dn,
+ mapping_ctr,
+ object_count,
+ first_object,
+ linked_attributes_count,
+ linked_attributes,
+ s_dsa,
+ uptodateness_vector,
+ c->gensec_skey,
+ 0,
+ s, &schema_objs);
if (!W_ERROR_IS_OK(status)) {
- DEBUG(0,("Failed to commit objects: %s\n", win_errstr(status)));
+ DEBUG(0,("Failed to convert objects when trying to import over DRS (2nd pass, to store remote schema): %s\n", win_errstr(status)));
return werror_to_ntstatus(status);
}
- if (lp_parm_bool(s->lp_ctx, NULL, "become dc", "dump objects", false)) {
- for (i=0; i < objs->num_objects; i++) {
+ if (lpcfg_parm_bool(s->lp_ctx, NULL, "become dc", "dump objects", false)) {
+ for (i=0; i < schema_objs->num_objects; i++) {
struct ldb_ldif ldif;
fprintf(stdout, "#\n");
ldif.changetype = LDB_CHANGETYPE_NONE;
- ldif.msg = objs->objects[i].msg;
+ ldif.msg = schema_objs->objects[i].msg;
ldb_ldif_write_file(s->ldb, stdout, &ldif);
- NDR_PRINT_DEBUG(replPropertyMetaDataBlob, objs->objects[i].meta_data);
+ NDR_PRINT_DEBUG(replPropertyMetaDataBlob, schema_objs->objects[i].meta_data);
}
}
- msg = ldb_msg_new(objs);
- NT_STATUS_HAVE_NO_MEMORY(msg);
- msg->dn = objs->partition_dn;
-
- status = dsdb_get_oid_mappings_ldb(s->schema, msg, &prefixMap_val, &schemaInfo_val);
+ status = dsdb_replicated_objects_commit(s->ldb, NULL, schema_objs, &seq_num);
if (!W_ERROR_IS_OK(status)) {
- DEBUG(0,("Failed dsdb_get_oid_mappings_ldb(%s)\n", win_errstr(status)));
+ DEBUG(0,("Failed to commit objects: %s\n", win_errstr(status)));
return werror_to_ntstatus(status);
}
- /* we only add prefixMap here, because schemaInfo is a replicated attribute and already applied */
- ret = ldb_msg_add_value(msg, "prefixMap", &prefixMap_val, &prefixMap_el);
+ msg = ldb_msg_new(schema_objs);
+ NT_STATUS_HAVE_NO_MEMORY(msg);
+ msg->dn = schema_objs->partition_dn;
+
+ /* We must ensure a prefixMap has been written. Unlike other
+ * attributes (including schemaInfo), it is not replicated in
+ * the normal replication stream. We can use the one from
+ * s->prefixmap_blob because we operate with one, unchanging
+ * prefixMap for this entire operation. */
+ ret = ldb_msg_add_value(msg, "prefixMap", &s->prefixmap_blob, &prefixMap_el);
if (ret != LDB_SUCCESS) {
return NT_STATUS_FOOBAR;
}
- prefixMap_el->flags = LDB_FLAG_MOD_REPLACE;
+ /* We want to know if a prefixMap was written already, as it
+ * would mean that the above comment was not true, and we have
+ * somehow updated the prefixMap during this transaction */
+ prefixMap_el->flags = LDB_FLAG_MOD_ADD;
- ret = ldb_modify(s->ldb, msg);
+ ret = dsdb_modify(s->ldb, msg, DSDB_FLAG_AS_SYSTEM);
if (ret != LDB_SUCCESS) {
- DEBUG(0,("Failed to add prefixMap and schemaInfo %s\n", ldb_strerror(ret)));
+ DEBUG(0,("Failed to add prefixMap: %s\n", ldb_errstring(s->ldb)));
return NT_STATUS_FOOBAR;
}
talloc_free(s_dsa);
- talloc_free(objs);
-
- /* We must set these up to ensure the replMetaData is written
- * correctly, before our NTDS Settings entry is replicated */
- ok = samdb_set_ntds_invocation_id(s->ldb, &c->dest_dsa->invocation_id);
- if (!ok) {
- DEBUG(0,("Failed to set cached ntds invocationId\n"));
- return NT_STATUS_FOOBAR;
- }
- ok = samdb_set_ntds_objectGUID(s->ldb, &c->dest_dsa->ntds_guid);
- if (!ok) {
- DEBUG(0,("Failed to set cached ntds objectGUID\n"));
- return NT_STATUS_FOOBAR;
- }
+ talloc_free(schema_objs);
- s->schema = dsdb_get_schema(s->ldb);
+ s->schema = dsdb_get_schema(s->ldb, s);
if (!s->schema) {
DEBUG(0,("Failed to get loaded dsdb_schema\n"));
return NT_STATUS_FOOBAR;
return NT_STATUS_OK;
}
-static NTSTATUS vampire_schema_chunk(void *private_data,
- const struct libnet_BecomeDC_StoreChunk *c)
+NTSTATUS libnet_vampire_cb_schema_chunk(void *private_data,
+ const struct libnet_BecomeDC_StoreChunk *c)
{
- struct vampire_state *s = talloc_get_type(private_data, struct vampire_state);
+ struct libnet_vampire_cb_state *s = talloc_get_type(private_data, struct libnet_vampire_cb_state);
WERROR status;
const struct drsuapi_DsReplicaOIDMapping_Ctr *mapping_ctr;
uint32_t nc_object_count;
+ uint32_t nc_total_received = 0;
uint32_t object_count;
struct drsuapi_DsReplicaObjectListItemEx *first_object;
struct drsuapi_DsReplicaObjectListItemEx *cur;
uint32_t nc_linked_attributes_count;
uint32_t linked_attributes_count;
- struct drsuapi_DsReplicaLinkedAttribute *linked_attributes;
switch (c->ctr_level) {
case 1:
first_object = c->ctr1->first_object;
nc_linked_attributes_count = 0;
linked_attributes_count = 0;
- linked_attributes = NULL;
break;
case 6:
mapping_ctr = &c->ctr6->mapping_ctr;
first_object = c->ctr6->first_object;
nc_linked_attributes_count = c->ctr6->nc_linked_attributes_count;
linked_attributes_count = c->ctr6->linked_attributes_count;
- linked_attributes = c->ctr6->linked_attributes;
break;
default:
return NT_STATUS_INVALID_PARAMETER;
}
+ if (!s->schema_part.first_object) {
+ nc_total_received = object_count;
+ } else {
+ nc_total_received = s->schema_part.object_count + object_count;
+ }
if (nc_object_count) {
DEBUG(0,("Schema-DN[%s] objects[%u/%u] linked_values[%u/%u]\n",
- c->partition->nc.dn, object_count, nc_object_count,
+ c->partition->nc.dn, nc_total_received, nc_object_count,
linked_attributes_count, nc_linked_attributes_count));
} else {
- DEBUG(0,("Schema-DN[%s] objects[%u] linked_values[%u\n",
- c->partition->nc.dn, object_count, linked_attributes_count));
+ DEBUG(0,("Schema-DN[%s] objects[%u] linked_values[%u]\n",
+ c->partition->nc.dn, nc_total_received, linked_attributes_count));
}
- if (!s->schema) {
- s->self_made_schema = dsdb_new_schema(s, lp_iconv_convenience(s->lp_ctx));
+ if (!s->self_made_schema) {
+ WERROR werr;
+ struct drsuapi_DsReplicaOIDMapping_Ctr mapping_ctr_without_schema_info;
+ /* Put the DRS prefixmap aside for the schema we are
+ * about to load in the provision, and into the one we
+ * are making with the help of DRS */
+ mapping_ctr_without_schema_info = *mapping_ctr;
+
+ /* This strips off the 0xFF schema info from the end,
+ * because we don't want it in the blob */
+ if (mapping_ctr_without_schema_info.num_mappings > 0) {
+ mapping_ctr_without_schema_info.num_mappings--;
+ }
+ werr = dsdb_get_drsuapi_prefixmap_as_blob(&mapping_ctr_without_schema_info, s, &s->prefixmap_blob);
+ if (!W_ERROR_IS_OK(werr)) {
+ return werror_to_ntstatus(werr);
+ }
+
+ /* Set up two manually-constructed schema - the local
+ * schema from the provision will be used to build
+ * one, which will then in turn be used to build the
+ * other. */
+ s->self_made_schema = dsdb_new_schema(s);
NT_STATUS_HAVE_NO_MEMORY(s->self_made_schema);
- status = dsdb_load_oid_mappings_drsuapi(s->self_made_schema, mapping_ctr);
+ status = dsdb_load_prefixmap_from_drsuapi(s->self_made_schema, mapping_ctr);
if (!W_ERROR_IS_OK(status)) {
return werror_to_ntstatus(status);
}
-
- s->schema = s->self_made_schema;
} else {
- status = dsdb_verify_oid_mappings_drsuapi(s->schema, mapping_ctr);
+ status = dsdb_schema_pfm_contains_drsuapi_pfm(s->self_made_schema->prefixmap, mapping_ctr);
if (!W_ERROR_IS_OK(status)) {
return werror_to_ntstatus(status);
}
s->schema_part.last_object = cur;
if (!c->partition->more_data) {
- return vampire_apply_schema(s, c);
+ return libnet_vampire_cb_apply_schema(s, c);
}
return NT_STATUS_OK;
}
-static NTSTATUS vampire_store_chunk(void *private_data,
- const struct libnet_BecomeDC_StoreChunk *c)
+NTSTATUS libnet_vampire_cb_store_chunk(void *private_data,
+ const struct libnet_BecomeDC_StoreChunk *c)
{
- struct vampire_state *s = talloc_get_type(private_data, struct vampire_state);
+ struct libnet_vampire_cb_state *s = talloc_get_type(private_data, struct libnet_vampire_cb_state);
WERROR status;
+ struct dsdb_schema *schema;
const struct drsuapi_DsReplicaOIDMapping_Ctr *mapping_ctr;
uint32_t nc_object_count;
uint32_t object_count;
struct drsuapi_DsReplicaLinkedAttribute *linked_attributes;
const struct drsuapi_DsReplicaCursor2CtrEx *uptodateness_vector;
struct dsdb_extended_replicated_objects *objs;
+ uint32_t req_replica_flags;
+ uint32_t dsdb_repl_flags = 0;
struct repsFromTo1 *s_dsa;
char *tmp_dns_name;
uint32_t i;
uint64_t seq_num;
+ bool is_exop = false;
+ struct ldb_dn *partition_dn = NULL;
+ struct ldb_dn *nc_root = NULL;
s_dsa = talloc_zero(s, struct repsFromTo1);
NT_STATUS_HAVE_NO_MEMORY(s_dsa);
return NT_STATUS_INVALID_PARAMETER;
}
- s_dsa->replica_flags = DRSUAPI_DS_REPLICA_NEIGHBOUR_WRITEABLE
- | DRSUAPI_DS_REPLICA_NEIGHBOUR_SYNC_ON_STARTUP
- | DRSUAPI_DS_REPLICA_NEIGHBOUR_DO_SCHEDULED_SYNCS;
+ switch (c->req_level) {
+ case 0:
+ /* none */
+ req_replica_flags = 0;
+ break;
+ case 5:
+ if (c->req5->extended_op != DRSUAPI_EXOP_NONE) {
+ is_exop = true;
+ }
+ req_replica_flags = c->req5->replica_flags;
+ break;
+ case 8:
+ if (c->req8->extended_op != DRSUAPI_EXOP_NONE) {
+ is_exop = true;
+ }
+ req_replica_flags = c->req8->replica_flags;
+ break;
+ case 10:
+ if (c->req10->extended_op != DRSUAPI_EXOP_NONE) {
+ is_exop = true;
+ }
+ req_replica_flags = c->req10->replica_flags;
+ break;
+ default:
+ return NT_STATUS_INVALID_PARAMETER;
+ }
+
+ if (req_replica_flags & DRSUAPI_DRS_CRITICAL_ONLY) {
+ /*
+ * If we only replicate the critical objects
+ * we should not remember what we already
+ * got, as it is incomplete.
+ */
+ ZERO_STRUCT(s_dsa->highwatermark);
+ uptodateness_vector = NULL;
+ }
+
+ /* TODO: avoid hardcoded flags */
+ s_dsa->replica_flags = DRSUAPI_DRS_WRIT_REP
+ | DRSUAPI_DRS_INIT_SYNC
+ | DRSUAPI_DRS_PER_SYNC;
memset(s_dsa->schedule, 0x11, sizeof(s_dsa->schedule));
tmp_dns_name = GUID_string(s_dsa->other_info, &s_dsa->source_dsa_obj_guid);
}
s->total_objects += object_count;
- if (nc_object_count) {
- DEBUG(0,("Partition[%s] objects[%u/%u] linked_values[%u/%u]\n",
- c->partition->nc.dn, s->total_objects, nc_object_count,
- linked_attributes_count, nc_linked_attributes_count));
+ partition_dn = ldb_dn_new(s, s->ldb, c->partition->nc.dn);
+ if (partition_dn == NULL) {
+ DEBUG(0,("Failed to parse partition DN from DRS.\n"));
+ return NT_STATUS_FOOBAR;
+ }
+
+ if (is_exop) {
+ int ret;
+ if (nc_object_count) {
+ DEBUG(0,("Exop on[%s] objects[%u/%u] linked_values[%u/%u]\n",
+ c->partition->nc.dn, s->total_objects, nc_object_count,
+ linked_attributes_count, nc_linked_attributes_count));
+ } else {
+ DEBUG(0,("Exop on[%s] objects[%u] linked_values[%u]\n",
+ c->partition->nc.dn, s->total_objects, linked_attributes_count));
+ }
+ ret = dsdb_find_nc_root(s->ldb, s,
+ partition_dn, &nc_root);
+ if (ret != LDB_SUCCESS) {
+ DEBUG(0,(__location__ ": Failed to find nc_root for %s\n",
+ ldb_dn_get_linearized(partition_dn)));
+ return NT_STATUS_INTERNAL_ERROR;
+ }
} else {
- DEBUG(0,("Partition[%s] objects[%u] linked_values[%u\n",
- c->partition->nc.dn, s->total_objects, linked_attributes_count));
- }
-
-
- status = dsdb_extended_replicated_objects_commit(s->ldb,
- c->partition->nc.dn,
- mapping_ctr,
- object_count,
- first_object,
- linked_attributes_count,
- linked_attributes,
- s_dsa,
- uptodateness_vector,
- c->gensec_skey,
- s, &objs, &seq_num);
+ if (nc_object_count) {
+ DEBUG(0,("Partition[%s] objects[%u/%u] linked_values[%u/%u]\n",
+ c->partition->nc.dn, s->total_objects, nc_object_count,
+ linked_attributes_count, nc_linked_attributes_count));
+ } else {
+ DEBUG(0,("Partition[%s] objects[%u] linked_values[%u]\n",
+ c->partition->nc.dn, s->total_objects, linked_attributes_count));
+ }
+ nc_root = partition_dn;
+ }
+
+
+ schema = dsdb_get_schema(s->ldb, NULL);
+ if (!schema) {
+ DEBUG(0,(__location__ ": Schema is not loaded yet!\n"));
+ return NT_STATUS_INTERNAL_ERROR;
+ }
+
+ if (req_replica_flags & DRSUAPI_DRS_FULL_SYNC_IN_PROGRESS) {
+ dsdb_repl_flags |= DSDB_REPL_FLAG_PRIORITISE_INCOMING;
+ }
+
+ if (req_replica_flags & DRSUAPI_DRS_SPECIAL_SECRET_PROCESSING) {
+ dsdb_repl_flags |= DSDB_REPL_FLAG_EXPECT_NO_SECRETS;
+ }
+
+ status = dsdb_replicated_objects_convert(s->ldb,
+ schema,
+ nc_root,
+ mapping_ctr,
+ object_count,
+ first_object,
+ linked_attributes_count,
+ linked_attributes,
+ s_dsa,
+ uptodateness_vector,
+ c->gensec_skey,
+ dsdb_repl_flags,
+ s, &objs);
if (!W_ERROR_IS_OK(status)) {
- DEBUG(0,("Failed to commit objects: %s\n", win_errstr(status)));
+ DEBUG(0,("Failed to convert objects: %s\n", win_errstr(status)));
return werror_to_ntstatus(status);
}
- if (lp_parm_bool(s->lp_ctx, NULL, "become dc", "dump objects", false)) {
+ if (lpcfg_parm_bool(s->lp_ctx, NULL, "become dc", "dump objects", false)) {
for (i=0; i < objs->num_objects; i++) {
struct ldb_ldif ldif;
fprintf(stdout, "#\n");
NDR_PRINT_DEBUG(replPropertyMetaDataBlob, objs->objects[i].meta_data);
}
}
+ status = dsdb_replicated_objects_commit(s->ldb, NULL, objs, &seq_num);
+ if (!W_ERROR_IS_OK(status)) {
+ DEBUG(0,("Failed to commit objects: %s\n", win_errstr(status)));
+ return werror_to_ntstatus(status);
+ }
+
talloc_free(s_dsa);
talloc_free(objs);
const struct dsdb_attribute *sa;
if (!linked_attributes[i].identifier) {
- return NT_STATUS_FOOBAR;
+ DEBUG(0, ("No linked attribute identifier\n"));
+ return NT_STATUS_FOOBAR;
}
if (!linked_attributes[i].value.blob) {
- return NT_STATUS_FOOBAR;
+ DEBUG(0, ("No linked attribute value\n"));
+ return NT_STATUS_FOOBAR;
}
sa = dsdb_attribute_by_attributeID_id(s->schema,
linked_attributes[i].attid);
if (!sa) {
+ DEBUG(0, ("Unable to find attribute via attribute id %d\n", linked_attributes[i].attid));
return NT_STATUS_FOOBAR;
}
- if (lp_parm_bool(s->lp_ctx, NULL, "become dc", "dump objects", false)) {
+ if (lpcfg_parm_bool(s->lp_ctx, NULL, "become dc", "dump objects", false)) {
DEBUG(0,("# %s\n", sa->lDAPDisplayName));
NDR_PRINT_DEBUG(drsuapi_DsReplicaLinkedAttribute, &linked_attributes[i]);
dump_data(0,
return NT_STATUS_OK;
}
-NTSTATUS libnet_Vampire(struct libnet_context *ctx, TALLOC_CTX *mem_ctx,
- struct libnet_Vampire *r)
-{
- struct libnet_JoinDomain *join;
- struct libnet_set_join_secrets *set_secrets;
- struct libnet_BecomeDC b;
- struct vampire_state *s;
- struct ldb_message *msg;
- int ldb_ret;
- uint32_t i;
- NTSTATUS status;
-
- const char *account_name;
- const char *netbios_name;
-
- r->out.error_string = NULL;
-
- s = talloc_zero(mem_ctx, struct vampire_state);
- if (!s) {
- return NT_STATUS_NO_MEMORY;
- }
-
- s->lp_ctx = ctx->lp_ctx;
- s->event_ctx = ctx->event_ctx;
-
- join = talloc_zero(s, struct libnet_JoinDomain);
- if (!join) {
- return NT_STATUS_NO_MEMORY;
- }
-
- if (r->in.netbios_name != NULL) {
- netbios_name = r->in.netbios_name;
- } else {
- netbios_name = talloc_reference(join, lp_netbios_name(ctx->lp_ctx));
- if (!netbios_name) {
- r->out.error_string = NULL;
- talloc_free(s);
- return NT_STATUS_NO_MEMORY;
- }
- }
-
- account_name = talloc_asprintf(join, "%s$", netbios_name);
- if (!account_name) {
- r->out.error_string = NULL;
- talloc_free(s);
- return NT_STATUS_NO_MEMORY;
- }
-
- join->in.domain_name = r->in.domain_name;
- join->in.account_name = account_name;
- join->in.netbios_name = netbios_name;
- join->in.level = LIBNET_JOINDOMAIN_AUTOMATIC;
- join->in.acct_type = ACB_WSTRUST;
- join->in.recreate_account = false;
- status = libnet_JoinDomain(ctx, join, join);
- if (!NT_STATUS_IS_OK(status)) {
- r->out.error_string = talloc_steal(mem_ctx, join->out.error_string);
- talloc_free(s);
- return status;
- }
-
- s->join = join;
-
- s->targetdir = r->in.targetdir;
-
- ZERO_STRUCT(b);
- b.in.domain_dns_name = join->out.realm;
- b.in.domain_netbios_name = join->out.domain_name;
- b.in.domain_sid = join->out.domain_sid;
- b.in.source_dsa_address = join->out.samr_binding->host;
- b.in.dest_dsa_netbios_name = netbios_name;
-
- b.in.callbacks.private_data = s;
- b.in.callbacks.check_options = vampire_check_options;
- b.in.callbacks.prepare_db = vampire_prepare_db;
- b.in.callbacks.schema_chunk = vampire_schema_chunk;
- b.in.callbacks.config_chunk = vampire_store_chunk;
- b.in.callbacks.domain_chunk = vampire_store_chunk;
-
- status = libnet_BecomeDC(ctx, s, &b);
- if (!NT_STATUS_IS_OK(status)) {
- printf("libnet_BecomeDC() failed - %s\n", nt_errstr(status));
- talloc_free(s);
- return status;
- }
-
- msg = ldb_msg_new(s);
- if (!msg) {
- printf("ldb_msg_new() failed\n");
- talloc_free(s);
- return NT_STATUS_NO_MEMORY;
- }
- msg->dn = ldb_dn_new(msg, s->ldb, "@ROOTDSE");
- if (!msg->dn) {
- printf("ldb_msg_new(@ROOTDSE) failed\n");
- talloc_free(s);
- return NT_STATUS_NO_MEMORY;
- }
-
- ldb_ret = ldb_msg_add_string(msg, "isSynchronized", "TRUE");
- if (ldb_ret != LDB_SUCCESS) {
- printf("ldb_msg_add_string(msg, isSynchronized, TRUE) failed: %d\n", ldb_ret);
- talloc_free(s);
- return NT_STATUS_NO_MEMORY;
- }
-
- for (i=0; i < msg->num_elements; i++) {
- msg->elements[i].flags = LDB_FLAG_MOD_REPLACE;
- }
-
- printf("mark ROOTDSE with isSynchronized=TRUE\n");
- ldb_ret = ldb_modify(s->ldb, msg);
- if (ldb_ret != LDB_SUCCESS) {
- printf("ldb_modify() failed: %d\n", ldb_ret);
- talloc_free(s);
- return NT_STATUS_INTERNAL_DB_ERROR;
- }
-
- /* commit the transaction - this commits all the changes in
- the ldb from the whole vampire. Note that this commit
- triggers the writing of the linked attribute backlinks.
- */
- if (ldb_transaction_commit(s->ldb) != LDB_SUCCESS) {
- printf("Failed to commit vampire transaction\n");
- return NT_STATUS_INTERNAL_DB_ERROR;
- }
-
- set_secrets = talloc_zero(s, struct libnet_set_join_secrets);
- if (!set_secrets) {
- return NT_STATUS_NO_MEMORY;
- }
-
- set_secrets->in.domain_name = join->out.domain_name;
- set_secrets->in.realm = join->out.realm;
- set_secrets->in.account_name = account_name;
- set_secrets->in.netbios_name = netbios_name;
- set_secrets->in.join_type = SEC_CHAN_BDC;
- set_secrets->in.join_password = join->out.join_password;
- set_secrets->in.kvno = join->out.kvno;
- set_secrets->in.domain_sid = join->out.domain_sid;
-
- status = libnet_set_join_secrets(ctx, set_secrets, set_secrets);
- if (!NT_STATUS_IS_OK(status)) {
- r->out.error_string = talloc_steal(mem_ctx, set_secrets->out.error_string);
- talloc_free(s);
- return status;
- }
-
- r->out.domain_name = talloc_steal(r, join->out.domain_name);
- r->out.domain_sid = talloc_steal(r, join->out.domain_sid);
- talloc_free(s);
-
- return NT_STATUS_OK;
-
-}
git.samba.org / sfrench / samba-autobuild / .git / blobdiff