#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/dom_sid.h"
+#include "libcli/security/security.h"
+#include "dsdb/common/util.h"
/*
List of tasks vampire.py must perform:
* converted, because we may not know them yet */
struct dsdb_schema *self_made_schema;
- /* 2nd pass, with full ID->OID->name table */
- struct dsdb_schema *self_corrected_schema;
-
/* prefixMap in LDB format, from the remote DRS server */
DATA_BLOB prefixmap_blob;
const struct dsdb_schema *schema;
struct tevent_context *event_ctx;
unsigned total_objects;
char *last_partition;
+ const char *server_dn_str;
};
+/* 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,
}
s->ldb = talloc_steal(s, result.samdb);
- s->lp_ctx = talloc_steal(s, result.lp_ctx);
+ 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 libnet_vampire_cb_apply_schema(struct libnet_vampire_cb_state *s,
const struct libnet_BecomeDC_StoreChunk *c)
{
+ struct schema_list {
+ struct schema_list *next, *prev;
+ const struct drsuapi_DsReplicaObjectListItemEx *obj;
+ };
+
WERROR status;
+ struct dsdb_schema_prefixmap *pfm_remote;
const struct drsuapi_DsReplicaOIDMapping_Ctr *mapping_ctr;
- uint32_t object_count;
+ struct schema_list *schema_list = NULL, *schema_list_item, *schema_list_next_item;
+ struct dsdb_schema *working_schema;
+ struct dsdb_schema *provision_schema;
+ uint32_t object_count = 0;
struct drsuapi_DsReplicaObjectListItemEx *first_object;
const struct drsuapi_DsReplicaObjectListItemEx *cur;
uint32_t linked_attributes_count;
struct ldb_message *msg;
struct ldb_message_element *prefixMap_el;
uint32_t i;
- int ret;
+ int ret, pass_no;
bool ok;
uint64_t seq_num;
+ uint32_t ignore_attids[] = {
+ DRSUAPI_ATTID_auxiliaryClass,
+ DRSUAPI_ATTID_mayContain,
+ DRSUAPI_ATTID_mustContain,
+ DRSUAPI_ATTID_possSuperiors,
+ DRSUAPI_ATTID_systemPossSuperiors,
+ DRSUAPI_ATTID_INVALID
+ };
DEBUG(0,("Analyze and apply schema objects\n"));
return NT_STATUS_INVALID_PARAMETER;
}
+ 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;
schema_ldb = provision_get_schema(s, s->lp_ctx, &s->prefixmap_blob);
if (!schema_ldb) {
- DEBUG(0,("Failed to re-load from local provision using remote prefixMap. Will continue with local prefixMap\n"));
- s->provision_schema = dsdb_get_schema(s->ldb, s);
+ 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 {
- s->provision_schema = dsdb_get_schema(schema_ldb, s);
- ret = dsdb_reference_schema(s->ldb, s->provision_schema, false);
+ 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);
}
- s->provision_schema->relax_OID_conversions = true;
+ /* create a list of objects yet to be converted */
+ for (cur = first_object; cur; cur = cur->next_object) {
+ schema_list_item = talloc(s, struct schema_list);
+ schema_list_item->obj = cur;
+ DLIST_ADD_END(schema_list, schema_list_item, struct schema_list);
+ }
+
+ /* resolve objects until all are resolved and in local schema */
+ pass_no = 1;
+ working_schema = provision_schema;
- /* Now convert the schema elements, using the schema we loaded locally */
- for (i=0, cur = first_object; cur; cur = cur->next_object, i++) {
- struct dsdb_extended_replicated_object object;
+ while (schema_list) {
+ uint32_t converted_obj_count = 0;
+ uint32_t failed_obj_count = 0;
TALLOC_CTX *tmp_ctx = talloc_new(s);
NT_STATUS_HAVE_NO_MEMORY(tmp_ctx);
- /* Convert the objects into LDB messages using the
- * provision schema, and either the provision or DRS
- * prefix map - it should not matter, as these are
- * just schema objects, so the critical parts. At
- * most we would mix up the mayContain etc for new
- * schema classes */
- status = dsdb_convert_object_ex(s->ldb, s->provision_schema,
- cur, c->gensec_skey,
- tmp_ctx, &object);
- if (!W_ERROR_IS_OK(status)) {
- DEBUG(1,("Warning: Failed to convert schema object %s into ldb msg\n", cur->object.identifier->dn));
- } else {
- /* Convert the schema from ldb_message format
- * (OIDs as OID strings) into schema, using
- * the remote prefixMap */
- status = dsdb_schema_set_el_from_ldb_msg(s->ldb, s->self_made_schema, object.msg);
+ 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
+ * the current one, so we can DLIST_REMOVE it
+ * safely */
+ schema_list_next_item = schema_list_item->next;
+
+ /*
+ * Convert the objects into LDB messages using the
+ * schema we have so far. It's ok if we fail to convert
+ * an object. We should convert more objects on next pass.
+ */
+ status = dsdb_convert_object_ex(s->ldb, working_schema, pfm_remote,
+ cur, c->gensec_skey,
+ ignore_attids,
+ tmp_ctx, &object);
if (!W_ERROR_IS_OK(status)) {
- DEBUG(1,("Warning: failed to convert object %s into a schema element: %s\n",
- ldb_dn_get_linearized(object.msg->dn),
- win_errstr(status)));
+ DEBUG(1,("Warning: Failed to convert schema object %s into ldb msg\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
+ */
+ status = dsdb_schema_set_el_from_ldb_msg(s->ldb,
+ s->self_made_schema,
+ object.msg);
+ if (!W_ERROR_IS_OK(status)) {
+ DEBUG(1,("Warning: failed to convert object %s into a schema element: %s\n",
+ ldb_dn_get_linearized(object.msg->dn),
+ win_errstr(status)));
+ failed_obj_count++;
+ } else {
+ DLIST_REMOVE(schema_list, schema_list_item);
+ converted_obj_count++;
+ }
}
}
talloc_free(tmp_ctx);
- }
- /* 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 1st pass schema from DRS.\n"));
- return NT_STATUS_FOOBAR;
- }
+ 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++;
- /* Now convert the schema elements again, using the schema we loaded over DRS */
- for (i=0, cur = first_object; cur; cur = cur->next_object, i++) {
- struct dsdb_extended_replicated_object object;
- TALLOC_CTX *tmp_ctx = talloc_new(s);
- NT_STATUS_HAVE_NO_MEMORY(tmp_ctx);
+ /* 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));
+ return NT_STATUS_INTERNAL_ERROR;
+ }
- /* Convert the objects into LDB messages using the
- * self_made_schema, and the DRS prefix map. We now
- * know the full schema int->OID->name mapping, so we
- * can get it right this time */
- status = dsdb_convert_object_ex(s->ldb, s->self_made_schema,
- cur, c->gensec_skey,
- tmp_ctx, &object);
- if (!W_ERROR_IS_OK(status)) {
- DEBUG(0,("ERROR: Failed to convert schema object %s into ldb msg\n", cur->object.identifier->dn));
- } else {
- /* Convert the schema from ldb_message format
- * (OIDs as OID strings) into schema, using
- * the remote prefixMap, now that we know
- * names for all the schema elements (from the
- * first conversion) */
- status = dsdb_schema_set_el_from_ldb_msg(s->ldb, s->self_corrected_schema, object.msg);
- if (!W_ERROR_IS_OK(status)) {
- DEBUG(0,("ERROR: failed to convert object %s into a schema element: %s\n",
- ldb_dn_get_linearized(object.msg->dn),
- win_errstr(status)));
+ if (schema_list) {
+ /* prepare for another cycle */
+ working_schema = s->self_made_schema;
+
+ ret = dsdb_setup_sorted_accessors(s->ldb, working_schema);
+ if (LDB_SUCCESS != ret) {
+ DEBUG(0,("Failed to create schema-cache indexes!\n"));
+ return NT_STATUS_INTERNAL_ERROR;
}
}
- talloc_free(tmp_ctx);
- }
+ };
- /* We don't want to use the s->self_made_schema any more */
- s->self_made_schema = NULL;
+ /* free temp objects for 1st conversion phase */
+ talloc_unlink(s, provision_schema);
+ TALLOC_FREE(schema_list);
- /* attach the schema we just brought over DRS to the ldb */
- ret = dsdb_set_schema(s->ldb, s->self_corrected_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 2nd pass (corrected) schema from DRS.\n"));
+ 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_corrected_schema;
- s->self_corrected_schema = NULL;
+ s->schema = s->self_made_schema;
+ s->self_made_schema = NULL;
/* Now convert the schema elements again, using the schema we finalised, ready to actually import */
- status = dsdb_extended_replicated_objects_convert(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, &schema_objs);
+ status = dsdb_replicated_objects_convert(s->ldb,
+ s->schema,
+ c->partition->nc.dn,
+ mapping_ctr,
+ object_count,
+ first_object,
+ linked_attributes_count,
+ linked_attributes,
+ s_dsa,
+ uptodateness_vector,
+ c->gensec_skey,
+ s, &schema_objs);
if (!W_ERROR_IS_OK(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)) {
+ 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");
}
}
- status = dsdb_extended_replicated_objects_commit(s->ldb, schema_objs, &seq_num);
+ status = dsdb_replicated_objects_commit(s->ldb, NULL, schema_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);
* other. */
s->self_made_schema = dsdb_new_schema(s);
NT_STATUS_HAVE_NO_MEMORY(s->self_made_schema);
- s->self_corrected_schema = dsdb_new_schema(s);
- NT_STATUS_HAVE_NO_MEMORY(s->self_corrected_schema);
status = dsdb_load_prefixmap_from_drsuapi(s->self_made_schema, mapping_ctr);
if (!W_ERROR_IS_OK(status)) {
return werror_to_ntstatus(status);
}
-
- status = dsdb_load_prefixmap_from_drsuapi(s->self_corrected_schema, mapping_ctr);
- if (!W_ERROR_IS_OK(status)) {
- return werror_to_ntstatus(status);
- }
} else {
status = dsdb_schema_pfm_contains_drsuapi_pfm(s->self_made_schema->prefixmap, mapping_ctr);
if (!W_ERROR_IS_OK(status)) {
{
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;
}
- status = dsdb_extended_replicated_objects_convert(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);
+ schema = dsdb_get_schema(s->ldb, NULL);
+ if (!schema) {
+ DEBUG(0,(__location__ ": Schema is not loaded yet!\n"));
+ return NT_STATUS_INTERNAL_ERROR;
+ }
+
+ status = dsdb_replicated_objects_convert(s->ldb,
+ schema,
+ c->partition->nc.dn,
+ mapping_ctr,
+ object_count,
+ first_object,
+ linked_attributes_count,
+ linked_attributes,
+ s_dsa,
+ uptodateness_vector,
+ c->gensec_skey,
+ s, &objs);
if (!W_ERROR_IS_OK(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_extended_replicated_objects_commit(s->ldb,
- objs, &seq_num);
+ 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);
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;
}
+static NTSTATUS update_dnshostname_for_server(TALLOC_CTX *mem_ctx,
+ struct ldb_context *ldb,
+ const char *server_dn_str,
+ const char *netbios_name,
+ const char *realm)
+{
+ int ret;
+ struct ldb_message *msg;
+ struct ldb_message_element *el;
+ struct ldb_dn *server_dn;
+ const char *dNSHostName = strlower_talloc(mem_ctx,
+ talloc_asprintf(mem_ctx,
+ "%s.%s",
+ netbios_name,
+ realm));
+ msg = ldb_msg_new(mem_ctx);
+ if (msg == NULL) {
+ return NT_STATUS_NO_MEMORY;
+ }
+
+ server_dn = ldb_dn_new(mem_ctx, ldb, server_dn_str);
+ if (!server_dn) {
+ return NT_STATUS_INTERNAL_ERROR;
+ }
+
+ msg->dn = server_dn;
+ ret = ldb_msg_add_empty(msg, "dNSHostName", LDB_FLAG_MOD_ADD, &el);
+ if (ret != LDB_SUCCESS) {
+ return NT_STATUS_INTERNAL_ERROR;
+ }
+
+ ret = ldb_msg_add_steal_string(msg,
+ "dNSHostName",
+ talloc_asprintf(el->values, "%s", dNSHostName));
+ if (ret != LDB_SUCCESS) {
+ return NT_STATUS_INTERNAL_ERROR;
+ }
+
+ ret = dsdb_modify(ldb, msg, DSDB_MODIFY_PERMISSIVE);
+ if (ret != LDB_SUCCESS) {
+ DEBUG(0,(__location__ ": Failed to add dnsHostName to the Server object: %s\n",
+ ldb_errstring(ldb)));
+ return NT_STATUS_INTERNAL_ERROR;
+ }
+
+ return NT_STATUS_OK;
+}
+
+
NTSTATUS libnet_Vampire(struct libnet_context *ctx, TALLOC_CTX *mem_ctx,
struct libnet_Vampire *r)
{
struct libnet_JoinDomain *join;
- struct provision_store_self_join_settings *set_secrets;
- struct libnet_BecomeDC b;
- struct libnet_vampire_cb_state *s;
- struct ldb_message *msg;
- const char *error_string;
- int ldb_ret;
- uint32_t i;
+ struct libnet_Replicate rep;
NTSTATUS status;
const char *account_name;
if (r->in.netbios_name != NULL) {
netbios_name = r->in.netbios_name;
} else {
- netbios_name = talloc_reference(join, lp_netbios_name(ctx->lp_ctx));
+ netbios_name = talloc_reference(join, lpcfg_netbios_name(ctx->lp_ctx));
if (!netbios_name) {
talloc_free(join);
r->out.error_string = NULL;
talloc_free(join);
return status;
}
+
+ rep.in.domain_name = join->out.domain_name;
+ rep.in.netbios_name = netbios_name;
+ rep.in.targetdir = r->in.targetdir;
+ rep.in.domain_sid = join->out.domain_sid;
+ rep.in.realm = join->out.realm;
+ rep.in.server = join->out.samr_binding->host;
+ rep.in.join_password = join->out.join_password;
+ rep.in.kvno = join->out.kvno;
+
+ status = libnet_Replicate(ctx, mem_ctx, &rep);
+
+ r->out.domain_sid = join->out.domain_sid;
+ r->out.domain_name = join->out.domain_name;
+ r->out.error_string = rep.out.error_string;
+
+ return status;
+}
+
+
+
+NTSTATUS libnet_Replicate(struct libnet_context *ctx, TALLOC_CTX *mem_ctx,
+ struct libnet_Replicate *r)
+{
+ struct provision_store_self_join_settings *set_secrets;
+ struct libnet_BecomeDC b;
+ struct libnet_vampire_cb_state *s;
+ struct ldb_message *msg;
+ const char *error_string;
+ int ldb_ret;
+ uint32_t i;
+ NTSTATUS status;
+ TALLOC_CTX *tmp_ctx = talloc_new(mem_ctx);
+ const char *account_name;
+ const char *netbios_name;
+
+ r->out.error_string = NULL;
+
+ netbios_name = r->in.netbios_name;
+ account_name = talloc_asprintf(tmp_ctx, "%s$", netbios_name);
+ if (!account_name) {
+ talloc_free(tmp_ctx);
+ r->out.error_string = NULL;
+ return NT_STATUS_NO_MEMORY;
+ }
+ /* Re-use the domain we are joining as the domain for the user
+ * to be authenticated with, unless they specified
+ * otherwise */
+ cli_credentials_set_domain(ctx->cred, r->in.domain_name, CRED_GUESS_ENV);
+
s = libnet_vampire_cb_state_init(mem_ctx, ctx->lp_ctx, ctx->event_ctx,
- netbios_name, join->out.domain_name, join->out.realm,
+ netbios_name, r->in.domain_name, r->in.realm,
r->in.targetdir);
if (!s) {
return NT_STATUS_NO_MEMORY;
}
- talloc_steal(s, join);
+ talloc_steal(s, tmp_ctx);
ZERO_STRUCT(b);
* We now know the domain and realm for sure - if they didn't
* put one on the command line, use this for the rest of the
* join */
- cli_credentials_set_realm(ctx->cred, join->out.realm, CRED_GUESS_ENV);
- cli_credentials_set_domain(ctx->cred, join->out.domain_name, CRED_GUESS_ENV);
+ cli_credentials_set_realm(ctx->cred, r->in.realm, CRED_GUESS_ENV);
+ cli_credentials_set_domain(ctx->cred, r->in.domain_name, CRED_GUESS_ENV);
/* Now set these values into the smb.conf - we probably had
* empty or useless defaults here from whatever smb.conf we
* started with */
- lp_set_cmdline(s->lp_ctx, "realm", join->out.realm);
- lp_set_cmdline(s->lp_ctx, "workgroup", join->out.domain_name);
+ lpcfg_set_cmdline(s->lp_ctx, "realm", r->in.realm);
+ lpcfg_set_cmdline(s->lp_ctx, "workgroup", r->in.domain_name);
- 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.domain_dns_name = r->in.realm;
+ b.in.domain_netbios_name = r->in.domain_name;
+ b.in.domain_sid = r->in.domain_sid;
+ b.in.source_dsa_address = r->in.server;
b.in.dest_dsa_netbios_name = netbios_name;
b.in.callbacks.private_data = s;
b.in.callbacks.config_chunk = libnet_vampire_cb_store_chunk;
b.in.callbacks.domain_chunk = libnet_vampire_cb_store_chunk;
- b.in.rodc_join = lp_parm_bool(s->lp_ctx, NULL, "repl", "RODC", false);
+ b.in.rodc_join = lpcfg_parm_bool(s->lp_ctx, NULL, "repl", "RODC", false);
status = libnet_BecomeDC(ctx, s, &b);
if (!NT_STATUS_IS_OK(status)) {
talloc_free(s);
return NT_STATUS_INTERNAL_DB_ERROR;
}
-
+ /* during dcpromo the 2nd computer adds dNSHostName attribute to his Server object
+ * the attribute appears on the original DC after replication
+ */
+ status = update_dnshostname_for_server(s, s->ldb, s->server_dn_str, s->netbios_name, s->realm);
+ if (!NT_STATUS_IS_OK(status)) {
+ printf("Failed to update dNSHostName on Server object - %s\n", nt_errstr(status));
+ talloc_free(s);
+ return status;
+ }
/* prepare the transaction - this prepares to commit all the changes in
the ldb from the whole vampire. Note that this
triggers the writing of the linked attribute backlinks.
}
ZERO_STRUCTP(set_secrets);
- set_secrets->domain_name = join->out.domain_name;
- set_secrets->realm = join->out.realm;
+ set_secrets->domain_name = r->in.domain_name;
+ set_secrets->realm = r->in.realm;
set_secrets->netbios_name = netbios_name;
set_secrets->secure_channel_type = SEC_CHAN_BDC;
- set_secrets->machine_password = join->out.join_password;
- set_secrets->key_version_number = join->out.kvno;
- set_secrets->domain_sid = join->out.domain_sid;
+ set_secrets->machine_password = r->in.join_password;
+ set_secrets->key_version_number = r->in.kvno;
+ set_secrets->domain_sid = r->in.domain_sid;
status = provision_store_self_join(ctx, s->lp_ctx, ctx->event_ctx, set_secrets, &error_string);
if (!NT_STATUS_IS_OK(status)) {
return status;
}
- r->out.domain_name = talloc_steal(mem_ctx, join->out.domain_name);
- r->out.domain_sid = dom_sid_dup(mem_ctx, join->out.domain_sid);
-
/* commit the transaction now we know the secrets were written
* out properly
*/
talloc_free(s);
return NT_STATUS_OK;
-
}