Don't use crossRef records to find our own domain

A single AD server can only host a single domain, so don't stuff about
with looking up our crossRef record in the cn=Partitions container.
We instead trust that lp_realm() and lp_workgroup() works correctly.

Andrew Bartlett

4 files changed, 79 insertions, 203 deletions

diff --git a/source4/rpc_server/config.mk b/source4/rpc_server/config.mk
index d05b0a0c0d..dfc3d17bed 100644
--- a/source4/rpc_server/config.mk
+++ b/source4/rpc_server/config.mk
@@ -129,7 +129,8 @@ PRIVATE_DEPENDENCIES = \
 		DCERPC_COMMON \
 		SCHANNELDB \
 		NDR_NETLOGON \
-		auth_sam
+		auth_sam \
+		LIBSAMBA-HOSTCONFIG
 # End MODULE dcerpc_netlogon
 ################################################
 
diff --git a/source4/rpc_server/lsa/lsa_init.c b/source4/rpc_server/lsa/lsa_init.c
index 8d8417109f..ae565a3ff1 100644
--- a/source4/rpc_server/lsa/lsa_init.c
+++ b/source4/rpc_server/lsa/lsa_init.c
@@ -26,7 +26,6 @@ NTSTATUS dcesrv_lsa_get_policy_state(struct dcesrv_call_state *dce_call, TALLOC_
 				     struct lsa_policy_state **_state)
 {
 	struct lsa_policy_state *state;
-	struct ldb_dn *partitions_basedn;
 	struct ldb_result *dom_res;
 	const char *dom_attrs[] = {
 		"objectSid", 
@@ -35,13 +34,7 @@ NTSTATUS dcesrv_lsa_get_policy_state(struct dcesrv_call_state *dce_call, TALLOC_
 		"fSMORoleOwner",
 		NULL
 	};
-	struct ldb_result *ref_res;
-	struct ldb_result *forest_ref_res;
-	const char *ref_attrs[] = {
-		"nETBIOSName",
-		"dnsRoot",
-		NULL
-	};
+	char *p;
 	int ret;
 
 	state = talloc(mem_ctx, struct lsa_policy_state);
@@ -55,11 +48,9 @@ NTSTATUS dcesrv_lsa_get_policy_state(struct dcesrv_call_state *dce_call, TALLOC_
 		return NT_STATUS_INVALID_SYSTEM_SERVICE;
 	}
 
-	partitions_basedn = samdb_partitions_dn(state->sam_ldb, mem_ctx);
-
 	/* work out the domain_dn - useful for so many calls its worth
 	   fetching here */
-	state->domain_dn = samdb_base_dn(state->sam_ldb);
+	state->domain_dn = ldb_get_default_basedn(state->sam_ldb);
 	if (!state->domain_dn) {
 		return NT_STATUS_NO_MEMORY;		
 	}
@@ -86,66 +77,30 @@ NTSTATUS dcesrv_lsa_get_policy_state(struct dcesrv_call_state *dce_call, TALLOC_
 	}
 
 	state->domain_guid = samdb_result_guid(dom_res->msgs[0], "objectGUID");
-	if (!state->domain_sid) {
-		return NT_STATUS_NO_SUCH_DOMAIN;		
-	}
 
 	state->mixed_domain = ldb_msg_find_attr_as_uint(dom_res->msgs[0], "nTMixedDomain", 0);
 	
 	talloc_free(dom_res);
 
-	ret = ldb_search(state->sam_ldb, state, &ref_res,
-				 partitions_basedn, LDB_SCOPE_SUBTREE, ref_attrs,
-				 "(&(objectclass=crossRef)(ncName=%s))",
-				 ldb_dn_get_linearized(state->domain_dn));
-	
-	if (ret != LDB_SUCCESS) {
-		talloc_free(ref_res);
-		return NT_STATUS_INVALID_SYSTEM_SERVICE;
-	}
-	if (ref_res->count != 1) {
-		talloc_free(ref_res);
-		return NT_STATUS_NO_SUCH_DOMAIN;		
-	}
-
-	state->domain_name = ldb_msg_find_attr_as_string(ref_res->msgs[0], "nETBIOSName", NULL);
-	if (!state->domain_name) {
-		talloc_free(ref_res);
-		return NT_STATUS_NO_SUCH_DOMAIN;		
-	}
-	talloc_steal(state, state->domain_name);
+	state->domain_name = lp_sam_name(dce_call->conn->dce_ctx->lp_ctx);
 
-	state->domain_dns = ldb_msg_find_attr_as_string(ref_res->msgs[0], "dnsRoot", NULL);
+	state->domain_dns = ldb_dn_canonical_string(state, state->domain_dn);
 	if (!state->domain_dns) {
-		talloc_free(ref_res);
 		return NT_STATUS_NO_SUCH_DOMAIN;		
 	}
-	talloc_steal(state, state->domain_dns);
-
-	talloc_free(ref_res);
-
-	ret = ldb_search(state->sam_ldb, state, &forest_ref_res,
-				 partitions_basedn, LDB_SCOPE_SUBTREE, ref_attrs,
-				 "(&(objectclass=crossRef)(ncName=%s))",
-				 ldb_dn_get_linearized(state->forest_dn));
-	
-	if (ret != LDB_SUCCESS) {
-		talloc_free(forest_ref_res);
-		return NT_STATUS_INVALID_SYSTEM_SERVICE;
-	}
-	if (forest_ref_res->count != 1) {
-		talloc_free(forest_ref_res);
-		return NT_STATUS_NO_SUCH_DOMAIN;		
+	p = strchr(state->domain_dns, '/');
+	if (p) {
+		*p = '\0';
 	}
 
-	state->forest_dns = ldb_msg_find_attr_as_string(forest_ref_res->msgs[0], "dnsRoot", NULL);
+	state->forest_dns = ldb_dn_canonical_string(state, state->forest_dn);
 	if (!state->forest_dns) {
-		talloc_free(forest_ref_res);
 		return NT_STATUS_NO_SUCH_DOMAIN;		
 	}
-	talloc_steal(state, state->forest_dns);
-
-	talloc_free(forest_ref_res);
+	p = strchr(state->forest_dns, '/');
+	if (p) {
+		*p = '\0';
+	}
 
 	/* work out the builtin_dn - useful for so many calls its worth
 	   fetching here */
diff --git a/source4/rpc_server/netlogon/dcerpc_netlogon.c b/source4/rpc_server/netlogon/dcerpc_netlogon.c
index b17ab86e26..51849fc52e 100644
--- a/source4/rpc_server/netlogon/dcerpc_netlogon.c
+++ b/source4/rpc_server/netlogon/dcerpc_netlogon.c
@@ -1010,8 +1010,9 @@ static WERROR dcesrv_netr_DsRGetSiteName(struct dcesrv_call_state *dce_call, TAL
   fill in a netr_DomainTrustInfo from a ldb search result
 */
 static NTSTATUS fill_domain_trust_info(TALLOC_CTX *mem_ctx,
+				       struct loadparm_context *lp_ctx,
+				       struct ldb_context *sam_ctx,
 				       struct ldb_message *res,
-				       struct ldb_message *ref_res,
 				       struct netr_DomainTrustInfo *info, 
 				       bool is_local, bool is_trust_list)
 {
@@ -1020,9 +1021,10 @@ static NTSTATUS fill_domain_trust_info(TALLOC_CTX *mem_ctx,
 	info->trust_extension.info = talloc_zero(mem_ctx, struct netr_trust_extension);
 	info->trust_extension.length = 16;
 	info->trust_extension.info->flags = 
-		NETR_TRUST_FLAG_TREEROOT | 
+		NETR_TRUST_FLAG_TREEROOT |
 		NETR_TRUST_FLAG_IN_FOREST | 
 		NETR_TRUST_FLAG_PRIMARY;
+
 	info->trust_extension.info->parent_index = 0; /* should be index into array
 							 of parent */
 	info->trust_extension.info->trust_type = LSA_TRUST_TYPE_UPLEVEL; /* should be based on ldb search for trusts */
@@ -1032,13 +1034,21 @@ static NTSTATUS fill_domain_trust_info(TALLOC_CTX *mem_ctx,
 		/* MS-NRPC 3.5.4.3.9 - must be set to NULL for trust list */
 		info->forest.string = NULL;
 	} else {
+		char *p;
 		/* TODO: we need a common function for pulling the forest */
-		info->forest.string = samdb_result_string(ref_res, "dnsRoot", NULL);
+		info->forest.string = ldb_dn_canonical_string(info, ldb_get_root_basedn(sam_ctx));
+		if (!info->forest.string) {
+			return NT_STATUS_NO_SUCH_DOMAIN;		
+		}
+		p = strchr(info->forest.string, '/');
+		if (p) {
+			*p = '\0';
+		}
 	}
 
 	if (is_local) {
-		info->domainname.string = samdb_result_string(ref_res, "nETBIOSName", NULL);
-		info->fulldomainname.string = samdb_result_string(ref_res, "dnsRoot", NULL);
+		info->domainname.string = lp_sam_name(lp_ctx);
+		info->fulldomainname.string = lp_realm(lp_ctx);
 		info->guid = samdb_result_guid(res, "objectGUID");
 		info->sid = samdb_result_dom_sid(mem_ctx, res, "objectSid");
 	} else {
@@ -1064,13 +1074,11 @@ static NTSTATUS dcesrv_netr_LogonGetDomainInfo(struct dcesrv_call_state *dce_cal
 	const char * const attrs[] = { "objectSid", 
 				       "objectGUID", "flatName", "securityIdentifier",
 				       "trustPartner", NULL };
-	const char * const ref_attrs[] = { "nETBIOSName", "dnsRoot", NULL };
 	struct ldb_context *sam_ctx;
-	struct ldb_message **res1, **res2, **ref_res;
+	struct ldb_message **res1, **res2;
 	struct netr_DomainInfo1 *info1;
-	int ret, ret1, ret2, i;
+	int ret1, ret2, i;
 	NTSTATUS status;
-	struct ldb_dn *partitions_basedn;
 
 	const char *local_domain;
 
@@ -1090,8 +1098,6 @@ static NTSTATUS dcesrv_netr_LogonGetDomainInfo(struct dcesrv_call_state *dce_cal
 		return NT_STATUS_INVALID_SYSTEM_SERVICE;
 	}
 
-	partitions_basedn = samdb_partitions_dn(sam_ctx, mem_ctx);
-
 	/* we need to do two searches. The first will pull our primary
 	   domain and the second will pull any trusted domains. Our
 	   primary domain is also a "trusted" domain, so we need to
@@ -1103,15 +1109,7 @@ static NTSTATUS dcesrv_netr_LogonGetDomainInfo(struct dcesrv_call_state *dce_cal
 	}
 
 	/* try and find the domain */
-	ret = gendb_search(sam_ctx, mem_ctx, partitions_basedn, 
-			   &ref_res, ref_attrs, 
-			   "(&(objectClass=crossRef)(ncName=%s))", 
-			   ldb_dn_get_linearized(res1[0]->dn));
-	if (ret != 1) {
-		return NT_STATUS_INTERNAL_DB_CORRUPTION;
-	}
-
-	local_domain = samdb_result_string(ref_res[0], "nETBIOSName", NULL);
+	local_domain = lp_sam_name(dce_call->conn->dce_ctx->lp_ctx);
 
 	ret2 = gendb_search(sam_ctx, mem_ctx, NULL, &res2, attrs, "(objectClass=trustedDomain)");
 	if (ret2 == -1) {
@@ -1128,21 +1126,21 @@ static NTSTATUS dcesrv_netr_LogonGetDomainInfo(struct dcesrv_call_state *dce_cal
 				       info1->num_trusts);
 	NT_STATUS_HAVE_NO_MEMORY(info1->trusts);
 
-	status = fill_domain_trust_info(mem_ctx, res1[0], ref_res[0], &info1->domaininfo, 
+	status = fill_domain_trust_info(mem_ctx, dce_call->conn->dce_ctx->lp_ctx, sam_ctx, res1[0], &info1->domaininfo, 
 					true, false);
 	NT_STATUS_NOT_OK_RETURN(status);
 
 	for (i=0;i<ret2;i++) {
-		status = fill_domain_trust_info(mem_ctx, res2[i], NULL, &info1->trusts[i], 
+		status = fill_domain_trust_info(mem_ctx, dce_call->conn->dce_ctx->lp_ctx, sam_ctx, res2[i], &info1->trusts[i], 
 						false, true);
 		NT_STATUS_NOT_OK_RETURN(status);
 	}
 
-	status = fill_domain_trust_info(mem_ctx, res1[0], ref_res[0], &info1->trusts[i], 
+	status = fill_domain_trust_info(mem_ctx, dce_call->conn->dce_ctx->lp_ctx, sam_ctx, res1[0], &info1->trusts[i], 
 					true, true);
 	NT_STATUS_NOT_OK_RETURN(status);
 
-	info1->dns_hostname.string = samdb_result_string(ref_res[0], "dnsRoot", NULL);
+	info1->dns_hostname.string = lp_realm(dce_call->conn->dce_ctx->lp_ctx);
 	info1->workstation_flags = 
 		NETR_WS_FLAG_HANDLES_INBOUND_TRUSTS | NETR_WS_FLAG_HANDLES_SPN_UPDATE;
 	info1->supported_enc_types = 0; /* w2008 gives this 0 */
@@ -1191,7 +1189,7 @@ static WERROR dcesrv_netr_DsRGetDCNameEx2(struct dcesrv_call_state *dce_call, TA
 				   struct netr_DsRGetDCNameEx2 *r)
 {
 	const char * const attrs[] = { "objectGUID", NULL };
-	void *sam_ctx;
+	struct ldb_context *sam_ctx;
 	struct ldb_message **res;
 	struct ldb_dn *domain_dn;
 	int ret;
@@ -1206,21 +1204,19 @@ static WERROR dcesrv_netr_DsRGetDCNameEx2(struct dcesrv_call_state *dce_call, TA
 
 	/* Win7-beta will send the domain name in the form the user typed, so we have to cope
 	   with both the short and long form here */
-	if (r->in.domain_name == NULL || strcasecmp(r->in.domain_name, lp_workgroup(dce_call->conn->dce_ctx->lp_ctx)) == 0) {
-		r->in.domain_name = lp_realm(dce_call->conn->dce_ctx->lp_ctx);
+	if (r->in.domain_name != NULL && !lp_is_my_domain_or_realm(dce_call->conn->dce_ctx->lp_ctx, 
+								r->in.domain_name)) {
+		return WERR_NO_SUCH_DOMAIN;
 	}
 
-	domain_dn = samdb_dns_domain_to_dn((struct ldb_context *)sam_ctx,
-					   mem_ctx,
-					   r->in.domain_name);   
+	domain_dn = ldb_get_default_basedn(sam_ctx);
 	if (domain_dn == NULL) {
 		return WERR_DS_SERVICE_UNAVAILABLE;
 	}
 
-	ret = gendb_search_dn((struct ldb_context *)sam_ctx, mem_ctx,
+	ret = gendb_search_dn(sam_ctx, mem_ctx,
 			      domain_dn, &res, attrs);
 	if (ret != 1) {
-		return WERR_NO_SUCH_DOMAIN;
 	}
 
 	info = talloc(mem_ctx, struct netr_DsRGetDCNameInfo);
@@ -1359,10 +1355,8 @@ static WERROR dcesrv_netr_DsrEnumerateDomainTrusts(struct dcesrv_call_state *dce
 	struct netr_DomainTrustList *trusts;
 	void *sam_ctx;
 	int ret;
-	struct ldb_message **dom_res, **ref_res;
+	struct ldb_message **dom_res;
 	const char * const dom_attrs[] = { "objectSid", "objectGUID", NULL };
-	const char * const ref_attrs[] = { "nETBIOSName", "dnsRoot", NULL };
-	struct ldb_dn *partitions_basedn;
 
 	ZERO_STRUCT(r->out);
 
@@ -1371,9 +1365,6 @@ static WERROR dcesrv_netr_DsrEnumerateDomainTrusts(struct dcesrv_call_state *dce
 		return WERR_GENERAL_FAILURE;
 	}
 
-	partitions_basedn = samdb_partitions_dn((struct ldb_context *)sam_ctx,
-						mem_ctx);
-
 	ret = gendb_search_dn((struct ldb_context *)sam_ctx, mem_ctx, NULL,
 			      &dom_res, dom_attrs);
 	if (ret == -1) {
@@ -1383,17 +1374,6 @@ static WERROR dcesrv_netr_DsrEnumerateDomainTrusts(struct dcesrv_call_state *dce
 		return WERR_GENERAL_FAILURE;
 	}
 
-	ret = gendb_search((struct ldb_context *)sam_ctx, mem_ctx,
-			   partitions_basedn, &ref_res, ref_attrs,
-			   "(&(objectClass=crossRef)(ncName=%s))",
-			   ldb_dn_get_linearized(dom_res[0]->dn));
-	if (ret == -1) {
-		return WERR_GENERAL_FAILURE;
-	}
-	if (ret != 1) {
-		return WERR_GENERAL_FAILURE;
-	}
-
 	trusts = talloc(mem_ctx, struct netr_DomainTrustList);
 	W_ERROR_HAVE_NO_MEMORY(trusts);
 
@@ -1406,8 +1386,8 @@ static WERROR dcesrv_netr_DsrEnumerateDomainTrusts(struct dcesrv_call_state *dce
 
 	/* TODO: add filtering by trust_flags, and correct trust_type
 	   and attributes */
-	trusts->array[0].netbios_name = samdb_result_string(ref_res[0], "nETBIOSName", NULL);
-	trusts->array[0].dns_name     = samdb_result_string(ref_res[0], "dnsRoot", NULL);
+	trusts->array[0].netbios_name = lp_sam_name(dce_call->conn->dce_ctx->lp_ctx);
+	trusts->array[0].dns_name     = lp_realm(dce_call->conn->dce_ctx->lp_ctx);
 	trusts->array[0].trust_flags =
 		NETR_TRUST_FLAG_TREEROOT | 
 		NETR_TRUST_FLAG_IN_FOREST | 
diff --git a/source4/rpc_server/samr/dcesrv_samr.c b/source4/rpc_server/samr/dcesrv_samr.c
index df23e11a67..fabc88d02d 100644
--- a/source4/rpc_server/samr/dcesrv_samr.c
+++ b/source4/rpc_server/samr/dcesrv_samr.c
@@ -273,11 +273,8 @@ static NTSTATUS dcesrv_samr_LookupDomain(struct dcesrv_call_state *dce_call, TAL
 	struct dcesrv_handle *h;
 	struct dom_sid *sid;
 	const char * const dom_attrs[] = { "objectSid", NULL};
-	const char * const ref_attrs[] = { "ncName", NULL};
 	struct ldb_message **dom_msgs;
-	struct ldb_message **ref_msgs;
 	int ret;
-	struct ldb_dn *partitions_basedn;
 
 	*r->out.sid = NULL;
 
@@ -289,27 +286,17 @@ static NTSTATUS dcesrv_samr_LookupDomain(struct dcesrv_call_state *dce_call, TAL
 		return NT_STATUS_INVALID_PARAMETER;
 	}
 
-	partitions_basedn = samdb_partitions_dn(c_state->sam_ctx, mem_ctx);
-
 	if (strcasecmp(r->in.domain_name->string, "BUILTIN") == 0) {
 		ret = gendb_search(c_state->sam_ctx,
 				   mem_ctx, NULL, &dom_msgs, dom_attrs,
 				   "(objectClass=builtinDomain)");
-	} else {
-		ret = gendb_search(c_state->sam_ctx,
-				   mem_ctx, partitions_basedn, &ref_msgs, ref_attrs,
-				   "(&(&(nETBIOSName=%s)(objectclass=crossRef))(ncName=*))", 
-				   ldb_binary_encode_string(mem_ctx, r->in.domain_name->string));
-		if (ret != 1) {
-			return NT_STATUS_NO_SUCH_DOMAIN;
-		}
-		
-		ret = gendb_search_dn(c_state->sam_ctx, mem_ctx, 
-				      samdb_result_dn(c_state->sam_ctx, mem_ctx,
-						      ref_msgs[0], "ncName", NULL), 
+	} else if (strcasecmp_m(r->in.domain_name->string, lp_sam_name(dce_call->conn->dce_ctx->lp_ctx)) == 0) {
+		ret = gendb_search_dn(c_state->sam_ctx,
+				      mem_ctx, ldb_get_default_basedn(c_state->sam_ctx), 
 				      &dom_msgs, dom_attrs);
+	} else {
+		return NT_STATUS_NO_SUCH_DOMAIN;
 	}
-
 	if (ret != 1) {
 		return NT_STATUS_NO_SUCH_DOMAIN;
 	}
@@ -338,12 +325,7 @@ static NTSTATUS dcesrv_samr_EnumDomains(struct dcesrv_call_state *dce_call, TALL
 	struct samr_connect_state *c_state;
 	struct dcesrv_handle *h;
 	struct samr_SamArray *array;
-	int i, start_i, ret;
-	const char * const dom_attrs[] = { "cn", NULL};
-	const char * const ref_attrs[] = { "nETBIOSName", NULL};
-	struct ldb_result *dom_res;
-	struct ldb_result *ref_res;
-	struct ldb_dn *partitions_basedn;
+	int i, start_i;
 
 	*r->out.resume_handle = 0;
 	*r->out.sam = NULL;
@@ -353,20 +335,11 @@ static NTSTATUS dcesrv_samr_EnumDomains(struct dcesrv_call_state *dce_call, TALL
 
 	c_state = h->data;
 
-	partitions_basedn = samdb_partitions_dn(c_state->sam_ctx, mem_ctx);
-
-	ret = ldb_search(c_state->sam_ctx, mem_ctx, &dom_res, ldb_get_default_basedn(c_state->sam_ctx),
-				 LDB_SCOPE_SUBTREE, dom_attrs, "(|(|(objectClass=domain)(objectClass=builtinDomain))(objectClass=samba4LocalDomain))");
-	if (ret != LDB_SUCCESS) {
-		DEBUG(0,("samdb: unable to find domains: %s\n", ldb_errstring(c_state->sam_ctx)));
-		return NT_STATUS_INTERNAL_DB_CORRUPTION;
-	}
-
-	*r->out.resume_handle = dom_res->count;
+	*r->out.resume_handle = 2;
 
 	start_i = *r->in.resume_handle;
 
-	if (start_i >= dom_res->count) {
+	if (start_i >= 2) {
 		/* search past end of list is not an error for this call */
 		return NT_STATUS_OK;
 	}
@@ -379,27 +352,17 @@ static NTSTATUS dcesrv_samr_EnumDomains(struct dcesrv_call_state *dce_call, TALL
 	array->count = 0;
 	array->entries = NULL;
 
-	array->entries = talloc_array(mem_ctx, struct samr_SamEntry, dom_res->count - start_i);
+	array->entries = talloc_array(mem_ctx, struct samr_SamEntry, 2 - start_i);
 	if (array->entries == NULL) {
 		return NT_STATUS_NO_MEMORY;
 	}
 
-	for (i=0;i<dom_res->count-start_i;i++) {
+	for (i=0;i<2-start_i;i++) {
 		array->entries[i].idx = start_i + i;
-		/* try and find the domain */
-		ret = ldb_search(c_state->sam_ctx, mem_ctx, &ref_res, partitions_basedn,
-					 LDB_SCOPE_SUBTREE, ref_attrs, "(&(objectClass=crossRef)(ncName=%s))", 
-					 ldb_dn_get_linearized(dom_res->msgs[i]->dn));
-
-		if (ret != LDB_SUCCESS) {
-			DEBUG(0,("samdb: unable to find domains: %s\n", ldb_errstring(c_state->sam_ctx)));
-			return NT_STATUS_INTERNAL_DB_CORRUPTION;
-		}
-
-		if (ref_res->count == 1) {
-			array->entries[i].name.string = samdb_result_string(ref_res->msgs[0], "nETBIOSName", NULL);
+		if (i == 0) {
+			array->entries[i].name.string = lp_sam_name(dce_call->conn->dce_ctx->lp_ctx);
 		} else {
-			array->entries[i].name.string = samdb_result_string(dom_res->msgs[i], "cn", NULL);
+			array->entries[i].name.string = "BUILTIN";
 		}
 	}
 
@@ -418,15 +381,11 @@ static NTSTATUS dcesrv_samr_OpenDomain(struct dcesrv_call_state *dce_call, TALLO
 				struct samr_OpenDomain *r)
 {
 	struct dcesrv_handle *h_conn, *h_domain;
-	const char *domain_name;
 	struct samr_connect_state *c_state;
 	struct samr_domain_state *d_state;
 	const char * const dom_attrs[] = { "cn", NULL};
-	const char * const ref_attrs[] = { "nETBIOSName", NULL};
 	struct ldb_message **dom_msgs;
-	struct ldb_message **ref_msgs;
 	int ret;
-	struct ldb_dn *partitions_basedn;
 
 	ZERO_STRUCTP(r->out.domain_handle);
 
@@ -438,63 +397,44 @@ static NTSTATUS dcesrv_samr_OpenDomain(struct dcesrv_call_state *dce_call, TALLO
 		return NT_STATUS_INVALID_PARAMETER;
 	}
 
-	partitions_basedn = samdb_partitions_dn(c_state->sam_ctx, mem_ctx);
+	d_state = talloc(c_state, struct samr_domain_state);
+	if (!d_state) {
+		return NT_STATUS_NO_MEMORY;
+	}
+
+	d_state->domain_sid = talloc_steal(d_state, r->in.sid);
+
+	if (dom_sid_equal(d_state->domain_sid, dom_sid_parse_talloc(mem_ctx, SID_BUILTIN))) {
+		d_state->builtin = true;
+		d_state->domain_name = "BUILTIN";
+	} else {
+		d_state->builtin = false;
+		d_state->domain_name = lp_sam_name(dce_call->conn->dce_ctx->lp_ctx);
+	}
 
 	ret = gendb_search(c_state->sam_ctx,
-			   mem_ctx, NULL, &dom_msgs, dom_attrs,
-			   "(&(objectSid=%s)(|(|(objectClass=domain)(objectClass=builtinDomain))(objectClass=samba4LocalDomain)))", 
+			   mem_ctx, ldb_get_default_basedn(c_state->sam_ctx), &dom_msgs, dom_attrs,
+			   "(objectSid=%s)", 
 			   ldap_encode_ndr_dom_sid(mem_ctx, r->in.sid));
+	
 	if (ret == 0) {
+		talloc_free(d_state);
 		return NT_STATUS_NO_SUCH_DOMAIN;
 	} else if (ret > 1) {
+		talloc_free(d_state);
 		return NT_STATUS_INTERNAL_DB_CORRUPTION;
 	} else if (ret == -1) {
+		talloc_free(d_state);
 		DEBUG(1, ("Failed to open domain %s: %s\n", dom_sid_string(mem_ctx, r->in.sid), ldb_errstring(c_state->sam_ctx)));
 		return NT_STATUS_INTERNAL_DB_CORRUPTION;
-	} else {
-		ret = gendb_search(c_state->sam_ctx,
-				   mem_ctx, partitions_basedn, &ref_msgs, ref_attrs,
-				   "(&(&(nETBIOSName=*)(objectclass=crossRef))(ncName=%s))", 
-				   ldb_dn_get_linearized(dom_msgs[0]->dn));
-		if (ret == 0) {
-			domain_name = ldb_msg_find_attr_as_string(dom_msgs[0], "cn", NULL);
-			if (domain_name == NULL) {
-				return NT_STATUS_NO_SUCH_DOMAIN;
-			}
-		} else if (ret == 1) {
-		
-			domain_name = ldb_msg_find_attr_as_string(ref_msgs[0], "nETBIOSName", NULL);
-			if (domain_name == NULL) {
-				return NT_STATUS_NO_SUCH_DOMAIN;
-			}
-		} else {
-			return NT_STATUS_NO_SUCH_DOMAIN;
-		}
-	}
-
-	d_state = talloc(c_state, struct samr_domain_state);
-	if (!d_state) {
-		return NT_STATUS_NO_MEMORY;
 	}
 
+	d_state->domain_dn = talloc_steal(d_state, dom_msgs[0]->dn);
 	d_state->role = lp_server_role(dce_call->conn->dce_ctx->lp_ctx);
 	d_state->connect_state = talloc_reference(d_state, c_state);
 	d_state->sam_ctx = c_state->sam_ctx;
-	d_state->domain_sid = dom_sid_dup(d_state, r->in.sid);
-	d_state->domain_name = talloc_strdup(d_state, domain_name);
-	d_state->domain_dn = ldb_dn_copy(d_state, dom_msgs[0]->dn);
-	if (!d_state->domain_sid || !d_state->domain_name || !d_state->domain_dn) {
-		talloc_free(d_state);
-		return NT_STATUS_NO_MEMORY;		
-	}
 	d_state->access_mask = r->in.access_mask;
 
-	if (dom_sid_equal(d_state->domain_sid, dom_sid_parse_talloc(mem_ctx, SID_BUILTIN))) {
-		d_state->builtin = true;
-	} else {
-		d_state->builtin = false;
-	}
-
 	d_state->lp_ctx = dce_call->conn->dce_ctx->lp_ctx;
 
 	h_domain = dcesrv_handle_new(dce_call->context, SAMR_HANDLE_DOMAIN);