Adding upstream version 2:4.17.12+dfsg.upstream/2%4.17.12+dfsgupstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

5 files changed, 5502 insertions, 0 deletions

diff --git a/source4/rpc_server/dnsserver/dcerpc_dnsserver.c b/source4/rpc_server/dnsserver/dcerpc_dnsserver.c
new file mode 100644
index 0000000..ea4d86d
--- /dev/null
+++ b/source4/rpc_server/dnsserver/dcerpc_dnsserver.c
@@ -0,0 +1,2431 @@
+/*
+   Unix SMB/CIFS implementation.
+
+   DNS Server
+
+   Copyright (C) Amitay Isaacs 2011
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "includes.h"
+#include "talloc.h"
+#include "rpc_server/dcerpc_server.h"
+#include "rpc_server/common/common.h"
+#include "dsdb/samdb/samdb.h"
+#include "lib/util/dlinklist.h"
+#include "librpc/gen_ndr/ndr_dnsserver.h"
+#include "dns_server/dnsserver_common.h"
+#include "dnsserver.h"
+
+#undef strcasecmp
+
+#define DCESRV_INTERFACE_DNSSERVER_BIND(context, iface) \
+	dcesrv_interface_dnsserver_bind(context, iface)
+static NTSTATUS dcesrv_interface_dnsserver_bind(struct dcesrv_connection_context *context,
+					        const struct dcesrv_interface *iface)
+{
+	return dcesrv_interface_bind_require_integrity(context, iface);
+}
+
+#define DNSSERVER_STATE_MAGIC 0xc9657ab4
+struct dnsserver_state {
+	struct loadparm_context *lp_ctx;
+	struct ldb_context *samdb;
+	struct dnsserver_partition *partitions;
+	struct dnsserver_zone *zones;
+	int zones_count;
+	struct dnsserver_serverinfo *serverinfo;
+};
+
+
+/* Utility functions */
+
+static void dnsserver_reload_zones(struct dnsserver_state *dsstate)
+{
+	struct dnsserver_partition *p;
+	struct dnsserver_zone *zones, *z, *znext, *zmatch;
+	struct dnsserver_zone *old_list, *new_list;
+
+	old_list = dsstate->zones;
+	new_list = NULL;
+
+	for (p = dsstate->partitions; p; p = p->next) {
+		zones = dnsserver_db_enumerate_zones(dsstate, dsstate->samdb, p);
+		if (zones == NULL) {
+			continue;
+		}
+		for (z = zones; z; ) {
+			znext = z->next;
+			zmatch = dnsserver_find_zone(old_list, z->name);
+			if (zmatch == NULL) {
+				/* Missing zone */
+				z->zoneinfo = dnsserver_init_zoneinfo(z, dsstate->serverinfo);
+				if (z->zoneinfo == NULL) {
+					continue;
+				}
+				DLIST_ADD_END(new_list, z);
+				p->zones_count++;
+				dsstate->zones_count++;
+			} else {
+				/* Existing zone */
+				talloc_free(z);
+				DLIST_REMOVE(old_list, zmatch);
+				DLIST_ADD_END(new_list, zmatch);
+			}
+			z = znext;
+		}
+	}
+
+	if (new_list == NULL) {
+		return;
+	}
+
+	/* Deleted zones */
+	for (z = old_list; z; ) {
+		znext = z->next;
+		z->partition->zones_count--;
+		dsstate->zones_count--;
+		talloc_free(z);
+		z = znext;
+	}
+
+	dsstate->zones = new_list;
+}
+
+
+static struct dnsserver_state *dnsserver_connect(struct dcesrv_call_state *dce_call)
+{
+	struct dnsserver_state *dsstate;
+	struct dnsserver_zone *zones, *z, *znext;
+	struct dnsserver_partition *partitions, *p;
+	NTSTATUS status;
+
+	dsstate = dcesrv_iface_state_find_conn(dce_call,
+					       DNSSERVER_STATE_MAGIC,
+					       struct dnsserver_state);
+	if (dsstate != NULL) {
+		return dsstate;
+	}
+
+	dsstate = talloc_zero(dce_call, struct dnsserver_state);
+	if (dsstate == NULL) {
+		return NULL;
+	}
+
+	dsstate->lp_ctx = dce_call->conn->dce_ctx->lp_ctx;
+
+	dsstate->samdb = dcesrv_samdb_connect_as_user(dsstate, dce_call);
+	if (dsstate->samdb == NULL) {
+		DEBUG(0,("dnsserver: Failed to open samdb"));
+		goto failed;
+	}
+
+	/* Initialize server info */
+	dsstate->serverinfo = dnsserver_init_serverinfo(dsstate,
+							dsstate->lp_ctx,
+							dsstate->samdb);
+	if (dsstate->serverinfo == NULL) {
+		goto failed;
+	}
+
+	/* Search for DNS partitions */
+	partitions = dnsserver_db_enumerate_partitions(dsstate, dsstate->serverinfo, dsstate->samdb);
+	if (partitions == NULL) {
+		goto failed;
+	}
+	dsstate->partitions = partitions;
+
+	/* Search for DNS zones */
+	for (p = partitions; p; p = p->next) {
+		zones = dnsserver_db_enumerate_zones(dsstate, dsstate->samdb, p);
+		if (zones == NULL) {
+			goto failed;
+		}
+		for (z = zones; z; ) {
+			znext = z->next;
+			if (dnsserver_find_zone(dsstate->zones, z->name) == NULL) {
+				z->zoneinfo = dnsserver_init_zoneinfo(z, dsstate->serverinfo);
+				if (z->zoneinfo == NULL) {
+					goto failed;
+				}
+				DLIST_ADD_END(dsstate->zones, z);
+				p->zones_count++;
+				dsstate->zones_count++;
+			} else {
+				/* Ignore duplicate zone */
+				DEBUG(3,("dnsserver: Ignoring duplicate zone '%s' from '%s'",
+					 z->name, ldb_dn_get_linearized(z->zone_dn)));
+			}
+			z = znext;
+		}
+	}
+
+	status = dcesrv_iface_state_store_conn(dce_call,
+					       DNSSERVER_STATE_MAGIC,
+					       dsstate);
+	if (!NT_STATUS_IS_OK(status)) {
+		goto failed;
+	}
+
+	return dsstate;
+
+failed:
+	talloc_free(dsstate);
+	dsstate = NULL;
+	return NULL;
+}
+
+
+/* dnsserver query functions */
+
+/* [MS-DNSP].pdf Section 3.1.1.1 DNS Server Configuration Information */
+static WERROR dnsserver_query_server(struct dnsserver_state *dsstate,
+					TALLOC_CTX *mem_ctx,
+					const char *operation,
+					const unsigned int client_version,
+					enum DNS_RPC_TYPEID *typeid,
+					union DNSSRV_RPC_UNION *r)
+{
+	uint8_t is_integer, is_addresses, is_string, is_wstring, is_stringlist;
+	uint32_t answer_integer;
+	struct IP4_ARRAY *answer_iparray;
+	struct DNS_ADDR_ARRAY *answer_addrarray;
+	char *answer_string;
+	struct DNS_RPC_UTF8_STRING_LIST *answer_stringlist;
+	struct dnsserver_serverinfo *serverinfo;
+
+	serverinfo = dsstate->serverinfo;
+
+	if (strcasecmp(operation, "ServerInfo") == 0) {
+		if (client_version == DNS_CLIENT_VERSION_W2K) {
+			*typeid = DNSSRV_TYPEID_SERVER_INFO_W2K;
+			r->ServerInfoW2K = talloc_zero(mem_ctx, struct DNS_RPC_SERVER_INFO_W2K);
+
+			r->ServerInfoW2K->dwVersion = serverinfo->dwVersion;
+			r->ServerInfoW2K->fBootMethod = serverinfo->fBootMethod;
+			r->ServerInfoW2K->fAdminConfigured = serverinfo->fAdminConfigured;
+			r->ServerInfoW2K->fAllowUpdate = serverinfo->fAllowUpdate;
+			r->ServerInfoW2K->fDsAvailable = serverinfo->fDsAvailable;
+			r->ServerInfoW2K->pszServerName = talloc_strdup(mem_ctx, serverinfo->pszServerName);
+			r->ServerInfoW2K->pszDsContainer = talloc_strdup(mem_ctx, serverinfo->pszDsContainer);
+			r->ServerInfoW2K->aipServerAddrs = dns_addr_array_to_ip4_array(mem_ctx,
+										       serverinfo->aipServerAddrs);
+			r->ServerInfoW2K->aipListenAddrs = dns_addr_array_to_ip4_array(mem_ctx,
+										       serverinfo->aipListenAddrs);
+			r->ServerInfoW2K->aipForwarders = ip4_array_copy(mem_ctx, serverinfo->aipForwarders);
+			r->ServerInfoW2K->dwLogLevel = serverinfo->dwLogLevel;
+			r->ServerInfoW2K->dwDebugLevel = serverinfo->dwDebugLevel;
+			r->ServerInfoW2K->dwForwardTimeout = serverinfo->dwForwardTimeout;
+			r->ServerInfoW2K->dwRpcProtocol = serverinfo->dwRpcProtocol;
+			r->ServerInfoW2K->dwNameCheckFlag = serverinfo->dwNameCheckFlag;
+			r->ServerInfoW2K->cAddressAnswerLimit = serverinfo->cAddressAnswerLimit;
+			r->ServerInfoW2K->dwRecursionRetry = serverinfo->dwRecursionRetry;
+			r->ServerInfoW2K->dwRecursionTimeout = serverinfo->dwRecursionTimeout;
+			r->ServerInfoW2K->dwMaxCacheTtl = serverinfo->dwMaxCacheTtl;
+			r->ServerInfoW2K->dwDsPollingInterval = serverinfo->dwDsPollingInterval;
+			r->ServerInfoW2K->dwScavengingInterval = serverinfo->dwScavengingInterval;
+			r->ServerInfoW2K->dwDefaultRefreshInterval = serverinfo->dwDefaultRefreshInterval;
+			r->ServerInfoW2K->dwDefaultNoRefreshInterval = serverinfo->dwDefaultNoRefreshInterval;
+			r->ServerInfoW2K->fAutoReverseZones = serverinfo->fAutoReverseZones;
+			r->ServerInfoW2K->fAutoCacheUpdate = serverinfo->fAutoCacheUpdate;
+			r->ServerInfoW2K->fRecurseAfterForwarding = serverinfo->fRecurseAfterForwarding;
+			r->ServerInfoW2K->fForwardDelegations = serverinfo->fForwardDelegations;
+			r->ServerInfoW2K->fNoRecursion = serverinfo->fNoRecursion;
+			r->ServerInfoW2K->fSecureResponses = serverinfo->fSecureResponses;
+			r->ServerInfoW2K->fRoundRobin = serverinfo->fRoundRobin;
+			r->ServerInfoW2K->fLocalNetPriority = serverinfo->fLocalNetPriority;
+			r->ServerInfoW2K->fBindSecondaries = serverinfo->fBindSecondaries;
+			r->ServerInfoW2K->fWriteAuthorityNs = serverinfo->fWriteAuthorityNs;
+			r->ServerInfoW2K->fStrictFileParsing = serverinfo->fStrictFileParsing;
+			r->ServerInfoW2K->fLooseWildcarding = serverinfo->fLooseWildcarding;
+			r->ServerInfoW2K->fDefaultAgingState = serverinfo->fDefaultAgingState;
+
+		} else if (client_version == DNS_CLIENT_VERSION_DOTNET) {
+			*typeid = DNSSRV_TYPEID_SERVER_INFO_DOTNET;
+			r->ServerInfoDotNet = talloc_zero(mem_ctx, struct DNS_RPC_SERVER_INFO_DOTNET);
+
+			r->ServerInfoDotNet->dwRpcStructureVersion = 0x01;
+			r->ServerInfoDotNet->dwVersion = serverinfo->dwVersion;
+			r->ServerInfoDotNet->fBootMethod = serverinfo->fBootMethod;
+			r->ServerInfoDotNet->fAdminConfigured = serverinfo->fAdminConfigured;
+			r->ServerInfoDotNet->fAllowUpdate = serverinfo->fAllowUpdate;
+			r->ServerInfoDotNet->fDsAvailable = serverinfo->fDsAvailable;
+			r->ServerInfoDotNet->pszServerName = talloc_strdup(mem_ctx, serverinfo->pszServerName);
+			r->ServerInfoDotNet->pszDsContainer = talloc_strdup(mem_ctx, serverinfo->pszDsContainer);
+			r->ServerInfoDotNet->aipServerAddrs = dns_addr_array_to_ip4_array(mem_ctx,
+											  serverinfo->aipServerAddrs);
+			r->ServerInfoDotNet->aipListenAddrs = dns_addr_array_to_ip4_array(mem_ctx,
+											  serverinfo->aipListenAddrs);
+			r->ServerInfoDotNet->aipForwarders = ip4_array_copy(mem_ctx, serverinfo->aipForwarders);
+			r->ServerInfoDotNet->aipLogFilter = ip4_array_copy(mem_ctx, serverinfo->aipLogFilter);
+			r->ServerInfoDotNet->pwszLogFilePath = talloc_strdup(mem_ctx, serverinfo->pwszLogFilePath);
+			r->ServerInfoDotNet->pszDomainName = talloc_strdup(mem_ctx, serverinfo->pszDomainName);
+			r->ServerInfoDotNet->pszForestName = talloc_strdup(mem_ctx, serverinfo->pszForestName);
+			r->ServerInfoDotNet->pszDomainDirectoryPartition = talloc_strdup(mem_ctx, serverinfo->pszDomainDirectoryPartition);
+			r->ServerInfoDotNet->pszForestDirectoryPartition = talloc_strdup(mem_ctx, serverinfo->pszForestDirectoryPartition);
+			r->ServerInfoDotNet->dwLogLevel = serverinfo->dwLogLevel;
+			r->ServerInfoDotNet->dwDebugLevel = serverinfo->dwDebugLevel;
+			r->ServerInfoDotNet->dwForwardTimeout = serverinfo->dwForwardTimeout;
+			r->ServerInfoDotNet->dwRpcProtocol = serverinfo->dwRpcProtocol;
+			r->ServerInfoDotNet->dwNameCheckFlag = serverinfo->dwNameCheckFlag;
+			r->ServerInfoDotNet->cAddressAnswerLimit = serverinfo->cAddressAnswerLimit;
+			r->ServerInfoDotNet->dwRecursionRetry = serverinfo->dwRecursionRetry;
+			r->ServerInfoDotNet->dwRecursionTimeout = serverinfo->dwRecursionTimeout;
+			r->ServerInfoDotNet->dwMaxCacheTtl = serverinfo->dwMaxCacheTtl;
+			r->ServerInfoDotNet->dwDsPollingInterval = serverinfo->dwDsPollingInterval;
+			r->ServerInfoDotNet->dwLocalNetPriorityNetMask = serverinfo->dwLocalNetPriorityNetMask;
+			r->ServerInfoDotNet->dwScavengingInterval = serverinfo->dwScavengingInterval;
+			r->ServerInfoDotNet->dwDefaultRefreshInterval = serverinfo->dwDefaultRefreshInterval;
+			r->ServerInfoDotNet->dwDefaultNoRefreshInterval = serverinfo->dwDefaultNoRefreshInterval;
+			r->ServerInfoDotNet->dwLastScavengeTime = serverinfo->dwLastScavengeTime;
+			r->ServerInfoDotNet->dwEventLogLevel = serverinfo->dwEventLogLevel;
+			r->ServerInfoDotNet->dwLogFileMaxSize = serverinfo->dwLogFileMaxSize;
+			r->ServerInfoDotNet->dwDsForestVersion = serverinfo->dwDsForestVersion;
+			r->ServerInfoDotNet->dwDsDomainVersion = serverinfo->dwDsDomainVersion;
+			r->ServerInfoDotNet->dwDsDsaVersion = serverinfo->dwDsDsaVersion;
+			r->ServerInfoDotNet->fAutoReverseZones = serverinfo->fAutoReverseZones;
+			r->ServerInfoDotNet->fAutoCacheUpdate = serverinfo->fAutoCacheUpdate;
+			r->ServerInfoDotNet->fRecurseAfterForwarding = serverinfo->fRecurseAfterForwarding;
+			r->ServerInfoDotNet->fForwardDelegations = serverinfo->fForwardDelegations;
+			r->ServerInfoDotNet->fNoRecursion = serverinfo->fNoRecursion;
+			r->ServerInfoDotNet->fSecureResponses = serverinfo->fSecureResponses;
+			r->ServerInfoDotNet->fRoundRobin = serverinfo->fRoundRobin;
+			r->ServerInfoDotNet->fLocalNetPriority = serverinfo->fLocalNetPriority;
+			r->ServerInfoDotNet->fBindSecondaries = serverinfo->fBindSecondaries;
+			r->ServerInfoDotNet->fWriteAuthorityNs = serverinfo->fWriteAuthorityNs;
+			r->ServerInfoDotNet->fStrictFileParsing = serverinfo->fStrictFileParsing;
+			r->ServerInfoDotNet->fLooseWildcarding = serverinfo->fLooseWildcarding;
+			r->ServerInfoDotNet->fDefaultAgingState = serverinfo->fDefaultAgingState;
+
+		} else if (client_version == DNS_CLIENT_VERSION_LONGHORN) {
+			*typeid = DNSSRV_TYPEID_SERVER_INFO;
+			r->ServerInfo = talloc_zero(mem_ctx, struct DNS_RPC_SERVER_INFO_LONGHORN);
+
+			r->ServerInfo->dwRpcStructureVersion = 0x02;
+			r->ServerInfo->dwVersion = serverinfo->dwVersion;
+			r->ServerInfo->fBootMethod = serverinfo->fBootMethod;
+			r->ServerInfo->fAdminConfigured = serverinfo->fAdminConfigured;
+			r->ServerInfo->fAllowUpdate = serverinfo->fAllowUpdate;
+			r->ServerInfo->fDsAvailable = serverinfo->fDsAvailable;
+			r->ServerInfo->pszServerName = talloc_strdup(mem_ctx, serverinfo->pszServerName);
+			r->ServerInfo->pszDsContainer = talloc_strdup(mem_ctx, serverinfo->pszDsContainer);
+			r->ServerInfo->aipServerAddrs = serverinfo->aipServerAddrs;
+			r->ServerInfo->aipListenAddrs = serverinfo->aipListenAddrs;
+			r->ServerInfo->aipForwarders = ip4_array_to_dns_addr_array(mem_ctx, serverinfo->aipForwarders);
+			r->ServerInfo->aipLogFilter = ip4_array_to_dns_addr_array(mem_ctx, serverinfo->aipLogFilter);
+			r->ServerInfo->pwszLogFilePath = talloc_strdup(mem_ctx, serverinfo->pwszLogFilePath);
+			r->ServerInfo->pszDomainName = talloc_strdup(mem_ctx, serverinfo->pszDomainName);
+			r->ServerInfo->pszForestName = talloc_strdup(mem_ctx, serverinfo->pszForestName);
+			r->ServerInfo->pszDomainDirectoryPartition = talloc_strdup(mem_ctx, serverinfo->pszDomainDirectoryPartition);
+			r->ServerInfo->pszForestDirectoryPartition = talloc_strdup(mem_ctx, serverinfo->pszForestDirectoryPartition);
+			r->ServerInfo->dwLogLevel = serverinfo->dwLogLevel;
+			r->ServerInfo->dwDebugLevel = serverinfo->dwDebugLevel;
+			r->ServerInfo->dwForwardTimeout = serverinfo->dwForwardTimeout;
+			r->ServerInfo->dwRpcProtocol = serverinfo->dwRpcProtocol;
+			r->ServerInfo->dwNameCheckFlag = serverinfo->dwNameCheckFlag;
+			r->ServerInfo->cAddressAnswerLimit = serverinfo->cAddressAnswerLimit;
+			r->ServerInfo->dwRecursionRetry = serverinfo->dwRecursionRetry;
+			r->ServerInfo->dwRecursionTimeout = serverinfo->dwRecursionTimeout;
+			r->ServerInfo->dwMaxCacheTtl = serverinfo->dwMaxCacheTtl;
+			r->ServerInfo->dwDsPollingInterval = serverinfo->dwDsPollingInterval;
+			r->ServerInfo->dwLocalNetPriorityNetMask = serverinfo->dwLocalNetPriorityNetMask;
+			r->ServerInfo->dwScavengingInterval = serverinfo->dwScavengingInterval;
+			r->ServerInfo->dwDefaultRefreshInterval = serverinfo->dwDefaultRefreshInterval;
+			r->ServerInfo->dwDefaultNoRefreshInterval = serverinfo->dwDefaultNoRefreshInterval;
+			r->ServerInfo->dwLastScavengeTime = serverinfo->dwLastScavengeTime;
+			r->ServerInfo->dwEventLogLevel = serverinfo->dwEventLogLevel;
+			r->ServerInfo->dwLogFileMaxSize = serverinfo->dwLogFileMaxSize;
+			r->ServerInfo->dwDsForestVersion = serverinfo->dwDsForestVersion;
+			r->ServerInfo->dwDsDomainVersion = serverinfo->dwDsDomainVersion;
+			r->ServerInfo->dwDsDsaVersion = serverinfo->dwDsDsaVersion;
+			r->ServerInfo->fReadOnlyDC = serverinfo->fReadOnlyDC;
+			r->ServerInfo->fAutoReverseZones = serverinfo->fAutoReverseZones;
+			r->ServerInfo->fAutoCacheUpdate = serverinfo->fAutoCacheUpdate;
+			r->ServerInfo->fRecurseAfterForwarding = serverinfo->fRecurseAfterForwarding;
+			r->ServerInfo->fForwardDelegations = serverinfo->fForwardDelegations;
+			r->ServerInfo->fNoRecursion = serverinfo->fNoRecursion;
+			r->ServerInfo->fSecureResponses = serverinfo->fSecureResponses;
+			r->ServerInfo->fRoundRobin = serverinfo->fRoundRobin;
+			r->ServerInfo->fLocalNetPriority = serverinfo->fLocalNetPriority;
+			r->ServerInfo->fBindSecondaries = serverinfo->fBindSecondaries;
+			r->ServerInfo->fWriteAuthorityNs = serverinfo->fWriteAuthorityNs;
+			r->ServerInfo->fStrictFileParsing = serverinfo->fStrictFileParsing;
+			r->ServerInfo->fLooseWildcarding = serverinfo->fLooseWildcarding;
+			r->ServerInfo->fDefaultAgingState = serverinfo->fDefaultAgingState;
+		}
+		return WERR_OK;
+	}
+
+	is_integer = 0;
+	answer_integer = 0;
+
+	if (strcasecmp(operation, "AddressAnswerLimit") == 0) {
+		answer_integer = serverinfo->cAddressAnswerLimit;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "AdminConfigured") == 0) {
+		answer_integer = serverinfo->fAdminConfigured;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "AllowCNAMEAtNS") == 0) {
+		answer_integer = 0;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "AllowUpdate") == 0) {
+		answer_integer = serverinfo->fAllowUpdate;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "AutoCacheUpdate") == 0) {
+		answer_integer = serverinfo->fAutoCacheUpdate;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "AutoConfigFileZones") == 0) {
+		answer_integer = 1;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "BindSecondaries") == 0) {
+		answer_integer = serverinfo->fBindSecondaries;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "BootMethod") == 0) {
+		answer_integer = serverinfo->fBootMethod;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "DebugLevel") == 0) {
+		answer_integer = serverinfo->dwDebugLevel;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "DefaultAgingState") == 0) {
+		answer_integer = serverinfo->fDefaultAgingState;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "DefaultNoRefreshInterval") == 0) {
+		answer_integer = serverinfo->dwDefaultNoRefreshInterval;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "DefaultRefreshInterval") == 0) {
+		answer_integer = serverinfo->dwDefaultRefreshInterval;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "DeleteOutsideGlue") == 0) {
+		answer_integer = 0;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "DisjointNets") == 0) {
+		answer_integer = 0;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "DsLazyUpdateInterval") == 0) {
+		answer_integer = 3; /* seconds */
+		is_integer = 1;
+	} else if (strcasecmp(operation, "DsPollingInterval") == 0) {
+		answer_integer = serverinfo->dwDsPollingInterval;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "DsTombstoneInterval") == 0) {
+		answer_integer = 0x00127500; /* 14 days */
+		is_integer = 1;
+	} else if (strcasecmp(operation, "EnableRegistryBoot") == 0) {
+		answer_integer = 0;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "EventLogLevel") == 0) {
+		answer_integer = serverinfo->dwEventLogLevel;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "ForceSoaSerial") == 0) {
+		answer_integer = 0;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "ForceSaoRetry") == 0) {
+		answer_integer = 0;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "ForceSoaRefresh") == 0) {
+		answer_integer = 0;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "ForceSoaMinimumTtl") == 0) {
+		answer_integer = 0;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "ForwardDelegations") == 0) {
+		answer_integer = 1;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "ForwardingTimeout") == 0) {
+		answer_integer = serverinfo->dwForwardTimeout;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "IsSlave") == 0) {
+		answer_integer = 0;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "LocalNetPriority") == 0) {
+		answer_integer = serverinfo->fLocalNetPriority;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "LogFileMaxSize") == 0) {
+		answer_integer = serverinfo->dwLogFileMaxSize;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "LogLevel") == 0) {
+		answer_integer = serverinfo->dwLogLevel;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "LooseWildcarding") == 0) {
+		answer_integer = serverinfo->fLooseWildcarding;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "MaxCacheTtl") == 0) {
+		answer_integer = serverinfo->dwMaxCacheTtl;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "MaxNegativeCacheTtl") == 0) {
+		answer_integer = 0x00000384; /* 15 minutes */
+		is_integer = 1;
+	} else if (strcasecmp(operation, "NameCheckFlag") == 0) {
+		answer_integer = serverinfo->dwNameCheckFlag;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "NoRecursion") == 0) {
+		answer_integer = serverinfo->fNoRecursion;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "NoUpdateDelegations") == 0) {
+		answer_integer = 1;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "PublishAutonet") == 0) {
+		answer_integer = 0;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "QuietRecvFaultInterval") == 0) {
+		answer_integer = 0;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "QuietRecvLogInterval") == 0) {
+		answer_integer = 0;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "RecursionRetry") == 0) {
+		answer_integer = serverinfo->dwRecursionRetry;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "RecursionTimeout") == 0) {
+		answer_integer = serverinfo->dwRecursionTimeout;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "ReloadException") == 0) {
+		answer_integer = 0;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "RoundRobin") == 0) {
+		answer_integer = serverinfo->fRoundRobin;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "RpcProtocol") == 0) {
+		answer_integer = serverinfo->dwRpcProtocol;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "SecureResponses") == 0) {
+		answer_integer = serverinfo->fSecureResponses;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "SendPort") == 0) {
+		answer_integer = 0;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "ScavengingInterval") == 0) {
+		answer_integer = serverinfo->dwScavengingInterval;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "SocketPoolSize") == 0) {
+		answer_integer = 0x000009C4;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "StrictFileParsing") == 0) {
+		answer_integer = serverinfo->fStrictFileParsing;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "SyncDnsZoneSerial") == 0) {
+		answer_integer = 2; /* ZONE_SERIAL_SYNC_XFER */
+		is_integer = 1;
+	} else if (strcasecmp(operation, "UpdateOptions") == 0) {
+		answer_integer = 0x0000030F; /* DNS_DEFAULT_UPDATE_OPTIONS */
+		is_integer = 1;
+	} else if (strcasecmp(operation, "UseSystemEvengLog") == 0) {
+		answer_integer = 0;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "Version") == 0) {
+		answer_integer = serverinfo->dwVersion;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "XfrConnectTimeout") == 0) {
+		answer_integer = 0x0000001E;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "WriteAuthorityNs") == 0) {
+		answer_integer = serverinfo->fWriteAuthorityNs;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "AdditionalRecursionTimeout") == 0) {
+		answer_integer = 0x00000004;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "AppendMsZoneTransferFlag") == 0) {
+		answer_integer = 0;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "AutoCreateDelegations") == 0) {
+		answer_integer = 0; /* DNS_ACD_DONT_CREATE */
+		is_integer = 1;
+	} else if (strcasecmp(operation, "BreakOnAscFailure") == 0) {
+		answer_integer = 0;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "CacheEmptyAuthResponses") == 0) {
+		answer_integer = 0;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "DirectoryPartitionAutoEnlistInterval") == 0) {
+		answer_integer = 0x00015180; /* 1 day */
+		is_integer = 1;
+	} else if (strcasecmp(operation, "DisableAutoReverseZones") == 0) {
+		answer_integer = ~serverinfo->fAutoReverseZones;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "EDnsCacheTimeout") == 0) {
+		answer_integer = 0x00000384; /* 15 minutes */
+		is_integer = 1;
+	} else if (strcasecmp(operation, "EnableDirectoryPartitions") == 0) {
+		answer_integer = serverinfo->fDsAvailable;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "EnableDnsSec") == 0) {
+		answer_integer = 0;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "EnableEDnsProbes") == 0) {
+		answer_integer = 0;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "EnableEDnsReception") == 0) {
+		answer_integer = 0;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "EnableIPv6") == 0) {
+		answer_integer = 0;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "EnableIQueryResponseGeneration") == 0) {
+		answer_integer = 0;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "EnableSendErrorSuppression") == 0) {
+		answer_integer = 0;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "EnableUpdateForwarding") == 0) {
+		answer_integer = 0;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "EnableWinsR") == 0) {
+		answer_integer = 0;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "ForceDsaBehaviorVersion") == 0) {
+		answer_integer = serverinfo->dwDsDsaVersion;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "ForceDomainBehaviorVersion") == 0) {
+		answer_integer = serverinfo->dwDsDsaVersion;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "ForceForestBehaviorVersion") == 0) {
+		answer_integer = serverinfo->dwDsDsaVersion;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "HeapDebug") == 0) {
+		answer_integer = 0;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "LameDelegationTtl") == 0) {
+		answer_integer = 0; /* seconds */
+		is_integer = 1;
+	} else if (strcasecmp(operation, "LocalNetPriorityNetMask") == 0) {
+		answer_integer = serverinfo->dwLocalNetPriorityNetMask;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "MaxCacheSize") == 0) {
+		answer_integer = 0;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "MaxResourceRecordsInNonSecureUpdate") == 0) {
+		answer_integer = 0x0000001E;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "OperationsLogLevel") == 0) {
+		answer_integer = 0;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "OperationsLogLevel2") == 0) {
+		answer_integer = 0;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "MaximumUdpPacketSize") == 0) {
+		answer_integer = 0x00004000; /* maximum possible */
+		is_integer = 1;
+	} else if (strcasecmp(operation, "RecurseToInternetRootMask") == 0) {
+		answer_integer = 0;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "SelfTest") == 0) {
+		answer_integer = 0;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "SilentlyIgnoreCNameUpdateConflicts") == 0) {
+		answer_integer = 1;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "TcpReceivePacketSize") == 0) {
+		answer_integer = 0x00010000;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "XfrThrottleMultiplier") == 0) {
+		answer_integer = 0x0000000A;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "AllowMsdcsLookupRetry") == 0) {
+		answer_integer = 1;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "AllowReadOnlyZoneTransfer") == 0) {
+		answer_integer = 0;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "DsBackGroundLoadPaused") == 0) {
+		answer_integer = 0;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "DsMinimumBackgroundLoadThreads") == 0) {
+		answer_integer = 0;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "DsRemoteReplicationDelay") == 0) {
+		answer_integer = 0x0000001E; /* 30 seconds */
+		is_integer = 1;
+	} else if (strcasecmp(operation, "EnableDuplicateQuerySuppresion") == 0) {
+		answer_integer = 0;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "EnableGlobalNamesSupport") == 0) {
+		answer_integer = 0;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "EnableVersionQuery") == 0) {
+		answer_integer = 1; /* DNS_VERSION_QUERY_FULL */
+		is_integer = 1;
+	} else if (strcasecmp(operation, "EnableRsoForRodc") == 0) {
+		answer_integer = 0;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "ForceRODCMode") == 0) {
+		answer_integer = 0;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "GlobalNamesAlwaysQuerySrv") == 0) {
+		answer_integer = 1;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "GlobalNamesBlockUpdates") == 0) {
+		answer_integer = 0;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "GlobalNamesEnableEDnsProbes") == 0) {
+		answer_integer = 0;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "GlobalNamesPreferAAAA") == 0) {
+		answer_integer = 0;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "GlobalNamesQueryOrder") == 0) {
+		answer_integer = 1;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "GlobalNamesSendTimeout") == 0) {
+		answer_integer = 3; /* seconds */
+		is_integer = 1;
+	} else if (strcasecmp(operation, "GlobalNamesServerQueryInterval") == 0) {
+		answer_integer = 0x00005460; /* 6 hours */
+		is_integer = 1;
+	} else if (strcasecmp(operation, "RemoteIPv4RankBoost") == 0) {
+		answer_integer = 0;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "RemoteIPv6RankBoost") == 0) {
+		answer_integer = 0;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "MaximumRodcRsoAttemptsPerCycle") == 0) {
+		answer_integer = 0x00000064;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "MaximumRodcRsoQueueLength") == 0) {
+		answer_integer = 0x0000012C;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "EnableGlobalQueryBlockList") == 0) {
+		answer_integer = 0;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "OpenACLOnProxyUpdates") == 0) {
+		answer_integer = 0;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "CacheLockingPercent") == 0) {
+		answer_integer = 0x00000064;
+		is_integer = 1;
+	}
+
+	if (is_integer == 1) {
+		*typeid = DNSSRV_TYPEID_DWORD;
+		r->Dword = answer_integer;
+		return WERR_OK;
+	}
+
+	is_addresses = 0;
+
+	if (strcasecmp(operation, "Forwarders") == 0) {
+		if (client_version == DNS_CLIENT_VERSION_LONGHORN) {
+			answer_addrarray = ip4_array_to_dns_addr_array(mem_ctx, serverinfo->aipForwarders);
+		} else {
+			answer_iparray = ip4_array_copy(mem_ctx, serverinfo->aipForwarders);
+		}
+		is_addresses = 1;
+	} else if (strcasecmp(operation, "ListenAddresses") == 0) {
+		if (client_version == DNS_CLIENT_VERSION_LONGHORN) {
+			answer_addrarray = serverinfo->aipListenAddrs;
+		} else {
+			answer_iparray = dns_addr_array_to_ip4_array(mem_ctx, serverinfo->aipListenAddrs);
+		}
+		is_addresses = 1;
+	} else if (strcasecmp(operation, "BreakOnReceiveFrom") == 0) {
+		if (client_version == DNS_CLIENT_VERSION_LONGHORN) {
+			answer_addrarray = NULL;
+		} else {
+			answer_iparray = NULL;
+		}
+		is_addresses = 1;
+	} else if (strcasecmp(operation, "BreakOnUpdateFrom") == 0) {
+		if (client_version == DNS_CLIENT_VERSION_LONGHORN) {
+			answer_addrarray = NULL;
+		} else {
+			answer_iparray = NULL;
+		}
+		is_addresses = 1;
+	} else if (strcasecmp(operation, "LogIPFilterList") == 0) {
+		if (client_version == DNS_CLIENT_VERSION_LONGHORN) {
+			answer_addrarray = ip4_array_to_dns_addr_array(mem_ctx, serverinfo->aipLogFilter);
+		} else {
+			answer_iparray = ip4_array_copy(mem_ctx, serverinfo->aipLogFilter);
+		}
+		is_addresses = 1;
+	}
+
+	if (is_addresses == 1) {
+		if (client_version == DNS_CLIENT_VERSION_LONGHORN) {
+			*typeid = DNSSRV_TYPEID_ADDRARRAY;
+			r->AddrArray = answer_addrarray;
+		} else {
+			*typeid = DNSSRV_TYPEID_IPARRAY;
+			r->IpArray = answer_iparray;
+		}
+		return WERR_OK;
+	}
+
+	is_string = is_wstring = 0;
+
+	if (strcasecmp(operation, "DomainDirectoryPartitionBaseName") == 0) {
+		answer_string = talloc_strdup(mem_ctx, "DomainDnsZones");
+		if (! answer_string) {
+			return WERR_OUTOFMEMORY;
+		}
+		is_string = 1;
+	} else if (strcasecmp(operation, "ForestDirectoryPartitionBaseName") == 0) {
+		answer_string = talloc_strdup(mem_ctx, "ForestDnsZones");
+		if (! answer_string) {
+			return WERR_OUTOFMEMORY;
+		}
+		is_string = 1;
+	} else if (strcasecmp(operation, "LogFilePath") == 0) {
+		answer_string = talloc_strdup(mem_ctx, serverinfo->pwszLogFilePath);
+		is_wstring = 1;
+	} else if (strcasecmp(operation, "ServerLevelPluginDll") == 0) {
+		answer_string = NULL;
+		is_wstring = 1;
+	} else if (strcasecmp(operation, "DsBackgroundPauseName") == 0) {
+		answer_string = NULL;
+		is_string = 1;
+	} else if (strcasecmp(operation, "DsNotRoundRobinTypes") == 0) {
+		answer_string = NULL;
+		is_string = 1;
+	}
+
+	if (is_string == 1) {
+		*typeid = DNSSRV_TYPEID_LPSTR;
+		r->String = answer_string;
+		return WERR_OK;
+	} else if (is_wstring == 1) {
+		*typeid = DNSSRV_TYPEID_LPWSTR;
+		r->WideString = answer_string;
+		return WERR_OK;
+	}
+
+	is_stringlist = 0;
+
+	if (strcasecmp(operation, "GlobalQueryBlockList") == 0) {
+		answer_stringlist = NULL;
+		is_stringlist = 1;
+	} else if (strcasecmp(operation, "SocketPoolExcludedPortRanges") == 0) {
+		answer_stringlist = NULL;
+		is_stringlist = 1;
+	}
+
+	if (is_stringlist == 1) {
+		*typeid = DNSSRV_TYPEID_UTF8_STRING_LIST;
+		r->Utf8StringList = answer_stringlist;
+		return WERR_OK;
+	}
+
+	DEBUG(0,("dnsserver: Invalid server operation %s", operation));
+	return WERR_DNS_ERROR_INVALID_PROPERTY;
+}
+
+/* [MS-DNSP].pdf Section 3.1.1.2 Zone Configuration Information */
+static WERROR dnsserver_query_zone(struct dnsserver_state *dsstate,
+					TALLOC_CTX *mem_ctx,
+					struct dnsserver_zone *z,
+					const char *operation,
+					const unsigned int client_version,
+					enum DNS_RPC_TYPEID *typeid,
+					union DNSSRV_RPC_UNION *r)
+{
+	uint8_t is_integer, is_addresses, is_string;
+	uint32_t answer_integer = 0;
+	struct IP4_ARRAY *answer_iparray;
+	struct DNS_ADDR_ARRAY *answer_addrarray;
+	char *answer_string;
+	struct dnsserver_zoneinfo *zoneinfo;
+
+	zoneinfo = z->zoneinfo;
+
+	if (strcasecmp(operation, "Zone") == 0) {
+		if (client_version == DNS_CLIENT_VERSION_W2K) {
+			*typeid = DNSSRV_TYPEID_ZONE_W2K;
+			r->ZoneW2K = talloc_zero(mem_ctx, struct DNS_RPC_ZONE_W2K);
+
+			r->ZoneW2K->pszZoneName = talloc_strdup(mem_ctx, z->name);
+			r->ZoneW2K->Flags = zoneinfo->Flags;
+			r->ZoneW2K->ZoneType = zoneinfo->dwZoneType;
+			r->ZoneW2K->Version = zoneinfo->Version;
+		} else {
+			*typeid = DNSSRV_TYPEID_ZONE;
+			r->Zone = talloc_zero(mem_ctx, struct DNS_RPC_ZONE_DOTNET);
+
+			r->Zone->dwRpcStructureVersion = 0x01;
+			r->Zone->pszZoneName = talloc_strdup(mem_ctx, z->name);
+			r->Zone->Flags = zoneinfo->Flags;
+			r->Zone->ZoneType = zoneinfo->dwZoneType;
+			r->Zone->Version = zoneinfo->Version;
+			r->Zone->dwDpFlags = z->partition->dwDpFlags;
+			r->Zone->pszDpFqdn = talloc_strdup(mem_ctx, z->partition->pszDpFqdn);
+		}
+		return WERR_OK;
+	}
+
+	if (strcasecmp(operation, "ZoneInfo") == 0) {
+		if (client_version == DNS_CLIENT_VERSION_W2K) {
+			*typeid = DNSSRV_TYPEID_ZONE_INFO_W2K;
+			r->ZoneInfoW2K = talloc_zero(mem_ctx, struct DNS_RPC_ZONE_INFO_W2K);
+
+			r->ZoneInfoW2K->pszZoneName = talloc_strdup(mem_ctx, z->name);
+			r->ZoneInfoW2K->dwZoneType = zoneinfo->dwZoneType;
+			r->ZoneInfoW2K->fReverse = zoneinfo->fReverse;
+			r->ZoneInfoW2K->fAllowUpdate = zoneinfo->fAllowUpdate;
+			r->ZoneInfoW2K->fPaused = zoneinfo->fPaused;
+			r->ZoneInfoW2K->fShutdown = zoneinfo->fShutdown;
+			r->ZoneInfoW2K->fAutoCreated = zoneinfo->fAutoCreated;
+			r->ZoneInfoW2K->fUseDatabase = zoneinfo->fUseDatabase;
+			r->ZoneInfoW2K->pszDataFile = talloc_strdup(mem_ctx, zoneinfo->pszDataFile);
+			r->ZoneInfoW2K->aipMasters = ip4_array_copy(mem_ctx, zoneinfo->aipMasters);
+			r->ZoneInfoW2K->fSecureSecondaries = zoneinfo->fSecureSecondaries;
+			r->ZoneInfoW2K->fNotifyLevel = zoneinfo->fNotifyLevel;
+			r->ZoneInfoW2K->aipSecondaries = ip4_array_copy(mem_ctx, zoneinfo->aipSecondaries);
+			r->ZoneInfoW2K->aipNotify = ip4_array_copy(mem_ctx, zoneinfo->aipNotify);
+			r->ZoneInfoW2K->fUseWins = zoneinfo->fUseWins;
+			r->ZoneInfoW2K->fUseNbstat = zoneinfo->fUseNbstat;
+			r->ZoneInfoW2K->fAging = zoneinfo->fAging;
+			r->ZoneInfoW2K->dwNoRefreshInterval = zoneinfo->dwNoRefreshInterval;
+			r->ZoneInfoW2K->dwRefreshInterval = zoneinfo->dwRefreshInterval;
+			r->ZoneInfoW2K->dwAvailForScavengeTime = zoneinfo->dwAvailForScavengeTime;
+			r->ZoneInfoW2K->aipScavengeServers = ip4_array_copy(mem_ctx, zoneinfo->aipScavengeServers);
+
+		} else if (client_version == DNS_CLIENT_VERSION_DOTNET) {
+			*typeid = DNSSRV_TYPEID_ZONE_INFO_DOTNET;
+			r->ZoneInfoDotNet = talloc_zero(mem_ctx, struct DNS_RPC_ZONE_INFO_DOTNET);
+
+			r->ZoneInfoDotNet->dwRpcStructureVersion = 0x01;
+			r->ZoneInfoDotNet->pszZoneName = talloc_strdup(mem_ctx, z->name);
+			r->ZoneInfoDotNet->dwZoneType = zoneinfo->dwZoneType;
+			r->ZoneInfoDotNet->fReverse = zoneinfo->fReverse;
+			r->ZoneInfoDotNet->fAllowUpdate = zoneinfo->fAllowUpdate;
+			r->ZoneInfoDotNet->fPaused = zoneinfo->fPaused;
+			r->ZoneInfoDotNet->fShutdown = zoneinfo->fShutdown;
+			r->ZoneInfoDotNet->fAutoCreated = zoneinfo->fAutoCreated;
+			r->ZoneInfoDotNet->fUseDatabase = zoneinfo->fUseDatabase;
+			r->ZoneInfoDotNet->pszDataFile = talloc_strdup(mem_ctx, zoneinfo->pszDataFile);
+			r->ZoneInfoDotNet->aipMasters = ip4_array_copy(mem_ctx, zoneinfo->aipMasters);
+			r->ZoneInfoDotNet->fSecureSecondaries = zoneinfo->fSecureSecondaries;
+			r->ZoneInfoDotNet->fNotifyLevel = zoneinfo->fNotifyLevel;
+			r->ZoneInfoDotNet->aipSecondaries = ip4_array_copy(mem_ctx, zoneinfo->aipSecondaries);
+			r->ZoneInfoDotNet->aipNotify = ip4_array_copy(mem_ctx, zoneinfo->aipNotify);
+			r->ZoneInfoDotNet->fUseWins = zoneinfo->fUseWins;
+			r->ZoneInfoDotNet->fUseNbstat = zoneinfo->fUseNbstat;
+			r->ZoneInfoDotNet->fAging = zoneinfo->fAging;
+			r->ZoneInfoDotNet->dwNoRefreshInterval = zoneinfo->dwNoRefreshInterval;
+			r->ZoneInfoDotNet->dwRefreshInterval = zoneinfo->dwRefreshInterval;
+			r->ZoneInfoDotNet->dwAvailForScavengeTime = zoneinfo->dwAvailForScavengeTime;
+			r->ZoneInfoDotNet->aipScavengeServers = ip4_array_copy(mem_ctx, zoneinfo->aipScavengeServers);
+			r->ZoneInfoDotNet->dwForwarderTimeout = zoneinfo->dwForwarderTimeout;
+			r->ZoneInfoDotNet->fForwarderSlave = zoneinfo->fForwarderSlave;
+			r->ZoneInfoDotNet->aipLocalMasters = ip4_array_copy(mem_ctx, zoneinfo->aipLocalMasters);
+			r->ZoneInfoDotNet->dwDpFlags = z->partition->dwDpFlags;
+			r->ZoneInfoDotNet->pszDpFqdn = talloc_strdup(mem_ctx, z->partition->pszDpFqdn);
+			r->ZoneInfoDotNet->pwszZoneDn = talloc_strdup(mem_ctx, zoneinfo->pwszZoneDn);
+			r->ZoneInfoDotNet->dwLastSuccessfulSoaCheck = zoneinfo->dwLastSuccessfulSoaCheck;
+			r->ZoneInfoDotNet->dwLastSuccessfulXfr = zoneinfo->dwLastSuccessfulXfr;
+
+		} else {
+			*typeid = DNSSRV_TYPEID_ZONE_INFO;
+			r->ZoneInfo = talloc_zero(mem_ctx, struct DNS_RPC_ZONE_INFO_LONGHORN);
+
+			r->ZoneInfo->dwRpcStructureVersion = 0x02;
+			r->ZoneInfo->pszZoneName = talloc_strdup(mem_ctx, z->name);
+			r->ZoneInfo->dwZoneType = zoneinfo->dwZoneType;
+			r->ZoneInfo->fReverse = zoneinfo->fReverse;
+			r->ZoneInfo->fAllowUpdate = zoneinfo->fAllowUpdate;
+			r->ZoneInfo->fPaused = zoneinfo->fPaused;
+			r->ZoneInfo->fShutdown = zoneinfo->fShutdown;
+			r->ZoneInfo->fAutoCreated = zoneinfo->fAutoCreated;
+			r->ZoneInfo->fUseDatabase = zoneinfo->fUseDatabase;
+			r->ZoneInfo->pszDataFile = talloc_strdup(mem_ctx, zoneinfo->pszDataFile);
+			r->ZoneInfo->aipMasters = ip4_array_to_dns_addr_array(mem_ctx, zoneinfo->aipMasters);
+			r->ZoneInfo->fSecureSecondaries = zoneinfo->fSecureSecondaries;
+			r->ZoneInfo->fNotifyLevel = zoneinfo->fNotifyLevel;
+			r->ZoneInfo->aipSecondaries = ip4_array_to_dns_addr_array(mem_ctx, zoneinfo->aipSecondaries);
+			r->ZoneInfo->aipNotify = ip4_array_to_dns_addr_array(mem_ctx, zoneinfo->aipNotify);
+			r->ZoneInfo->fUseWins = zoneinfo->fUseWins;
+			r->ZoneInfo->fUseNbstat = zoneinfo->fUseNbstat;
+			r->ZoneInfo->fAging = zoneinfo->fAging;
+			r->ZoneInfo->dwNoRefreshInterval = zoneinfo->dwNoRefreshInterval;
+			r->ZoneInfo->dwRefreshInterval = zoneinfo->dwRefreshInterval;
+			r->ZoneInfo->dwAvailForScavengeTime = zoneinfo->dwAvailForScavengeTime;
+			r->ZoneInfo->aipScavengeServers = ip4_array_to_dns_addr_array(mem_ctx, zoneinfo->aipScavengeServers);
+			r->ZoneInfo->dwForwarderTimeout = zoneinfo->dwForwarderTimeout;
+			r->ZoneInfo->fForwarderSlave = zoneinfo->fForwarderSlave;
+			r->ZoneInfo->aipLocalMasters = ip4_array_to_dns_addr_array(mem_ctx, zoneinfo->aipLocalMasters);
+			r->ZoneInfo->dwDpFlags = z->partition->dwDpFlags;
+			r->ZoneInfo->pszDpFqdn = talloc_strdup(mem_ctx, z->partition->pszDpFqdn);
+			r->ZoneInfo->pwszZoneDn = talloc_strdup(mem_ctx, zoneinfo->pwszZoneDn);
+			r->ZoneInfo->dwLastSuccessfulSoaCheck = zoneinfo->dwLastSuccessfulSoaCheck;
+			r->ZoneInfo->dwLastSuccessfulXfr = zoneinfo->dwLastSuccessfulXfr;
+
+			r->ZoneInfo->fQueuedForBackgroundLoad = zoneinfo->fQueuedForBackgroundLoad;
+			r->ZoneInfo->fBackgroundLoadInProgress = zoneinfo->fBackgroundLoadInProgress;
+			r->ZoneInfo->fReadOnlyZone = zoneinfo->fReadOnlyZone;
+			r->ZoneInfo->dwLastXfrAttempt = zoneinfo->dwLastXfrAttempt;
+			r->ZoneInfo->dwLastXfrResult = zoneinfo->dwLastXfrResult;
+		}
+
+		return WERR_OK;
+	}
+
+	is_integer = 0;
+
+	if (strcasecmp(operation, "AllowUpdate") == 0) {
+		answer_integer = zoneinfo->fAllowUpdate;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "Secured") == 0) {
+		answer_integer = 0;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "DsIntegrated") == 0) {
+		answer_integer = zoneinfo->fUseDatabase;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "LogUpdates") == 0) {
+		answer_integer = 0;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "NoRefreshInterval") == 0) {
+		answer_integer = zoneinfo->dwNoRefreshInterval;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "NotifyLevel") == 0) {
+		answer_integer = zoneinfo->fNotifyLevel;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "RefreshInterval") == 0) {
+		answer_integer = zoneinfo->dwRefreshInterval;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "SecureSecondaries") == 0) {
+		answer_integer = zoneinfo->fSecureSecondaries;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "Type") == 0) {
+		answer_integer = zoneinfo->dwZoneType;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "Aging") == 0) {
+		answer_integer = zoneinfo->fAging;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "ForwarderSlave") == 0) {
+		answer_integer = zoneinfo->fForwarderSlave;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "ForwarderTimeout") == 0) {
+		answer_integer = zoneinfo->dwForwarderTimeout;
+		is_integer = 1;
+	} else if (strcasecmp(operation, "Unicode") == 0) {
+		answer_integer = 0;
+		is_integer = 1;
+	}
+
+	if (is_integer == 1) {
+		*typeid = DNSSRV_TYPEID_DWORD;
+		r->Dword = answer_integer;
+		return WERR_OK;
+	}
+
+	is_addresses = 0;
+
+	if (strcasecmp(operation, "AllowNSRecordsAutoCreation") == 0) {
+		if (client_version == DNS_CLIENT_VERSION_LONGHORN) {
+			answer_addrarray = NULL;
+		} else {
+			answer_iparray = NULL;
+		}
+		is_addresses = 1;
+	} else if (strcasecmp(operation, "ScavengeServers") == 0) {
+		if (client_version == DNS_CLIENT_VERSION_LONGHORN) {
+			answer_addrarray = ip4_array_to_dns_addr_array(mem_ctx, zoneinfo->aipScavengeServers);
+		} else {
+			answer_iparray = ip4_array_copy(mem_ctx, zoneinfo->aipScavengeServers);
+		}
+		is_addresses = 1;
+	} else if (strcasecmp(operation, "MasterServers") == 0) {
+		if (client_version == DNS_CLIENT_VERSION_LONGHORN) {
+			answer_addrarray = ip4_array_to_dns_addr_array(mem_ctx, zoneinfo->aipMasters);
+		} else {
+			answer_iparray = ip4_array_copy(mem_ctx, zoneinfo->aipMasters);
+		}
+		is_addresses = 1;
+	} else if (strcasecmp(operation, "LocalMasterServers") == 0) {
+		if (client_version == DNS_CLIENT_VERSION_LONGHORN) {
+			answer_addrarray = ip4_array_to_dns_addr_array(mem_ctx, zoneinfo->aipLocalMasters);
+		} else {
+			answer_iparray = ip4_array_copy(mem_ctx, zoneinfo->aipLocalMasters);
+		}
+		is_addresses = 1;
+	} else if (strcasecmp(operation, "NotifyServers") == 0) {
+		if (client_version == DNS_CLIENT_VERSION_LONGHORN) {
+			answer_addrarray = ip4_array_to_dns_addr_array(mem_ctx, zoneinfo->aipNotify);
+		} else {
+			answer_iparray = ip4_array_copy(mem_ctx, zoneinfo->aipNotify);
+		}
+		is_addresses = 1;
+	} else if (strcasecmp(operation, "SecondaryServers") == 0) {
+		if (client_version == DNS_CLIENT_VERSION_LONGHORN) {
+			answer_addrarray = ip4_array_to_dns_addr_array(mem_ctx, zoneinfo->aipSecondaries);
+		} else {
+			answer_iparray = ip4_array_copy(mem_ctx, zoneinfo->aipSecondaries);
+		}
+		is_addresses = 1;
+	}
+
+	if (is_addresses == 1) {
+		if (client_version == DNS_CLIENT_VERSION_LONGHORN) {
+			*typeid = DNSSRV_TYPEID_ADDRARRAY;
+			r->AddrArray = answer_addrarray;
+		} else {
+			*typeid = DNSSRV_TYPEID_IPARRAY;
+			r->IpArray = answer_iparray;
+		}
+		return WERR_OK;
+	}
+
+	is_string = 0;
+
+	if (strcasecmp(operation, "DatabaseFile") == 0) {
+		answer_string = talloc_strdup(mem_ctx, zoneinfo->pszDataFile);
+		is_string = 1;
+	} else if (strcasecmp(operation, "ApplicationDirectoryPartition") == 0) {
+		answer_string = talloc_strdup(mem_ctx, z->partition->pszDpFqdn);
+		is_string = 1;
+	} else if (strcasecmp(operation, "BreakOnNameUpdate") == 0) {
+		answer_string = NULL;
+		is_string = 1;
+	}
+
+	if (is_string == 1) {
+		*typeid = DNSSRV_TYPEID_LPSTR;
+		r->String = answer_string;
+		return WERR_OK;
+	}
+
+	DEBUG(0,("dnsserver: Invalid zone operation %s", operation));
+	return WERR_DNS_ERROR_INVALID_PROPERTY;
+
+}
+
+/* dnsserver operation functions */
+
+/* [MS-DNSP].pdf Section 3.1.1.1 DNS Server Configuration Information */
+static WERROR dnsserver_operate_server(struct dnsserver_state *dsstate,
+					TALLOC_CTX *mem_ctx,
+					const char *operation,
+					const unsigned int client_version,
+					enum DNS_RPC_TYPEID typeid,
+					union DNSSRV_RPC_UNION *r)
+{
+	bool valid_operation = false;
+
+	if (strcasecmp(operation, "ResetDwordProperty") == 0) {
+		valid_operation = true;
+	} else if (strcasecmp(operation, "Restart") == 0) {
+		valid_operation = true;
+	} else if (strcasecmp(operation, "ClearDebugLog") == 0) {
+		valid_operation = true;
+	} else if (strcasecmp(operation, "ClearCache") == 0) {
+		valid_operation = true;
+	} else if (strcasecmp(operation, "WriteDirtyZones") == 0) {
+		valid_operation = true;
+	} else if (strcasecmp(operation, "ZoneCreate") == 0) {
+		struct dnsserver_zone *z, *z2;
+		WERROR status;
+		size_t len;
+		const char *name;
+		z = talloc_zero(mem_ctx, struct dnsserver_zone);
+		W_ERROR_HAVE_NO_MEMORY(z);
+		z->partition = talloc_zero(z, struct dnsserver_partition);
+		W_ERROR_HAVE_NO_MEMORY_AND_FREE(z->partition, z);
+		z->zoneinfo = talloc_zero(z, struct dnsserver_zoneinfo);
+		W_ERROR_HAVE_NO_MEMORY_AND_FREE(z->zoneinfo, z);
+
+		if (typeid == DNSSRV_TYPEID_ZONE_CREATE_W2K) {
+			name = r->ZoneCreateW2K->pszZoneName;
+			z->zoneinfo->dwZoneType = r->ZoneCreateW2K->dwZoneType;
+			z->zoneinfo->fAllowUpdate = r->ZoneCreateW2K->fAllowUpdate;
+			z->zoneinfo->fAging = r->ZoneCreateW2K->fAging;
+			z->zoneinfo->Flags = r->ZoneCreateW2K->dwFlags;
+		} else if (typeid == DNSSRV_TYPEID_ZONE_CREATE_DOTNET) {
+			name = r->ZoneCreateDotNet->pszZoneName;
+			z->zoneinfo->dwZoneType = r->ZoneCreateDotNet->dwZoneType;
+			z->zoneinfo->fAllowUpdate = r->ZoneCreateDotNet->fAllowUpdate;
+			z->zoneinfo->fAging = r->ZoneCreateDotNet->fAging;
+			z->zoneinfo->Flags = r->ZoneCreateDotNet->dwFlags;
+			z->partition->dwDpFlags = r->ZoneCreateDotNet->dwDpFlags;
+		} else if (typeid == DNSSRV_TYPEID_ZONE_CREATE) {
+			name = r->ZoneCreate->pszZoneName;
+			z->zoneinfo->dwZoneType = r->ZoneCreate->dwZoneType;
+			z->zoneinfo->fAllowUpdate = r->ZoneCreate->fAllowUpdate;
+			z->zoneinfo->fAging = r->ZoneCreate->fAging;
+			z->zoneinfo->Flags = r->ZoneCreate->dwFlags;
+			z->partition->dwDpFlags = r->ZoneCreate->dwDpFlags;
+		} else {
+			talloc_free(z);
+			return WERR_DNS_ERROR_INVALID_PROPERTY;
+		}
+
+		len = strlen(name);
+		if (name[len-1] == '.') {
+			len -= 1;
+		}
+		z->name = talloc_strndup(z, name, len);
+		if (z->name == NULL) {
+			talloc_free(z);
+			return WERR_NOT_ENOUGH_MEMORY;
+		}
+
+		z2 = dnsserver_find_zone(dsstate->zones, z->name);
+		if (z2 != NULL) {
+			talloc_free(z);
+			return WERR_DNS_ERROR_ZONE_ALREADY_EXISTS;
+		}
+
+		status = dnsserver_db_create_zone(dsstate->samdb, dsstate->partitions, z,
+						  dsstate->lp_ctx);
+		talloc_free(z);
+
+		if (W_ERROR_IS_OK(status)) {
+			dnsserver_reload_zones(dsstate);
+		}
+		return status;
+	} else if (strcasecmp(operation, "ClearStatistics") == 0) {
+		valid_operation = true;
+	} else if (strcasecmp(operation, "EnlistDirectoryPartition") == 0) {
+		valid_operation = true;
+	} else if (strcasecmp(operation, "StartScavenging") == 0) {
+		valid_operation = true;
+	} else if (strcasecmp(operation, "AbortScavenging") == 0) {
+		valid_operation = true;
+	} else if (strcasecmp(operation, "AutoConfigure") == 0) {
+		valid_operation = true;
+	} else if (strcasecmp(operation, "ExportSettings") == 0) {
+		valid_operation = true;
+	} else if (strcasecmp(operation, "PrepareForDemotion") == 0) {
+		valid_operation = true;
+	} else if (strcasecmp(operation, "PrepareForUninstall") == 0) {
+		valid_operation = true;
+	} else if (strcasecmp(operation, "DeleteNode") == 0) {
+		valid_operation = true;
+	} else if (strcasecmp(operation, "DeleteRecord") == 0) {
+		valid_operation = true;
+	} else if (strcasecmp(operation, "WriteBackFile") == 0) {
+		valid_operation = true;
+	} else if (strcasecmp(operation, "ListenAddresses") == 0) {
+		valid_operation = true;
+	} else if (strcasecmp(operation, "Forwarders") == 0) {
+		valid_operation = true;
+	} else if (strcasecmp(operation, "LogFilePath") == 0) {
+		valid_operation = true;
+	} else if (strcasecmp(operation, "LogIpFilterList") == 0) {
+		valid_operation = true;
+	} else if (strcasecmp(operation, "ForestDirectoryPartitionBaseName") == 0) {
+		valid_operation = true;
+	} else if (strcasecmp(operation, "DomainDirectoryPartitionBaseName") == 0) {
+		valid_operation = true;
+	} else if (strcasecmp(operation, "GlobalQueryBlockList") == 0) {
+		valid_operation = true;
+	} else if (strcasecmp(operation, "BreakOnReceiveFrom") == 0) {
+		valid_operation = true;
+	} else if (strcasecmp(operation, "BreakOnUpdateFrom") == 0) {
+		valid_operation = true;
+	} else if (strcasecmp(operation, "ServerLevelPluginDll") == 0) {
+		valid_operation = true;
+	}
+
+	if (valid_operation) {
+		DEBUG(0, ("dnsserver: server operation '%s' not implemented", operation));
+		return WERR_CALL_NOT_IMPLEMENTED;
+	}
+
+	DEBUG(0, ("dnsserver: invalid server operation '%s'", operation));
+	return WERR_DNS_ERROR_INVALID_PROPERTY;
+}
+
+static WERROR dnsserver_complex_operate_server(struct dnsserver_state *dsstate,
+					TALLOC_CTX *mem_ctx,
+					const char *operation,
+					const unsigned int client_version,
+					enum DNS_RPC_TYPEID typeid_in,
+					union DNSSRV_RPC_UNION *rin,
+					enum DNS_RPC_TYPEID *typeid_out,
+					union DNSSRV_RPC_UNION *rout)
+{
+	int valid_operation = 0;
+	struct dnsserver_zone *z, **zlist;
+	size_t zcount;
+	bool found1, found2, found3, found4;
+	size_t i;
+
+	if (strcasecmp(operation, "QueryDwordProperty") == 0) {
+		if (typeid_in == DNSSRV_TYPEID_LPSTR) {
+			return dnsserver_query_server(dsstate, mem_ctx,
+							rin->String,
+							client_version,
+							typeid_out,
+							rout);
+		}
+	} else if (strcasecmp(operation, "EnumZones") == 0) {
+		if (typeid_in != DNSSRV_TYPEID_DWORD) {
+			return WERR_DNS_ERROR_INVALID_PROPERTY;
+		}
+
+		zcount = 0;
+		zlist = talloc_zero_array(mem_ctx, struct dnsserver_zone *, 0);
+		for (z = dsstate->zones; z; z = z->next) {
+
+			/* Match the flags in groups
+			 *
+			 * Group1 : PRIMARY, SECONDARY, CACHE, AUTO
+			 * Group2 : FORWARD, REVERSE, FORWARDER, STUB
+			 * Group3 : DS, NON_DS, DOMAIN_DP, FOREST_DP
+			 * Group4 : CUSTOM_DP, LEGACY_DP
+			 */
+			
+			/* Group 1 */
+			found1 = false;
+			if (rin->Dword & 0x0000000f) {
+				if (rin->Dword & DNS_ZONE_REQUEST_PRIMARY) {
+					if (z->zoneinfo->dwZoneType == DNS_ZONE_TYPE_PRIMARY) {
+					found1 = true;
+					}
+				}
+				if (rin->Dword & DNS_ZONE_REQUEST_SECONDARY) {
+					if (z->zoneinfo->dwZoneType == DNS_ZONE_TYPE_SECONDARY) {
+						found1 = true;
+					}
+				}
+				if (rin->Dword & DNS_ZONE_REQUEST_CACHE) {
+					if (z->zoneinfo->dwZoneType == DNS_ZONE_TYPE_CACHE) {
+						found1 = true;
+					}
+				}
+				if (rin->Dword & DNS_ZONE_REQUEST_AUTO) {
+					if (z->zoneinfo->fAutoCreated 
+						|| z->partition->dwDpFlags & DNS_DP_AUTOCREATED) {
+						found1 = true;
+					}
+				}
+			} else {
+				found1 = true;
+			}
+
+			/* Group 2 */
+			found2 = false;
+			if (rin->Dword & 0x000000f0) {
+				if (rin->Dword & DNS_ZONE_REQUEST_FORWARD) {
+					if (!(z->zoneinfo->fReverse)) {
+						found2 = true;
+					}
+				}
+				if (rin->Dword & DNS_ZONE_REQUEST_REVERSE) {
+					if (z->zoneinfo->fReverse) {
+						found2 = true;
+					}
+				}
+				if (rin->Dword & DNS_ZONE_REQUEST_FORWARDER) {
+					if (z->zoneinfo->dwZoneType == DNS_ZONE_TYPE_FORWARDER) {
+						found2 = true;
+					}
+				}
+				if (rin->Dword & DNS_ZONE_REQUEST_STUB) {
+					if (z->zoneinfo->dwZoneType == DNS_ZONE_TYPE_STUB) {
+						found2 = true;
+					}
+				}
+			} else {
+				found2 = true;
+			}
+
+			/* Group 3 */
+			found3 = false;
+			if (rin->Dword & 0x00000f00) {
+				if (rin->Dword & DNS_ZONE_REQUEST_DS) {
+					if (z->zoneinfo->Flags & DNS_RPC_ZONE_DSINTEGRATED) {
+						found3 = true;
+					}
+				}
+				if (rin->Dword & DNS_ZONE_REQUEST_NON_DS) {
+					if (!(z->zoneinfo->Flags & DNS_RPC_ZONE_DSINTEGRATED)) {
+						found3 = true;
+					}
+				}
+				if (rin->Dword & DNS_ZONE_REQUEST_DOMAIN_DP) {
+					if (!(z->partition->dwDpFlags & DNS_DP_DOMAIN_DEFAULT)) {
+						found3 = true;
+					}
+				}
+				if (rin->Dword & DNS_ZONE_REQUEST_FOREST_DP) {
+					if (!(z->partition->dwDpFlags & DNS_DP_FOREST_DEFAULT)) {
+						found3 = true;
+					}
+				}
+			} else {
+				found3 = true;
+			}
+	
+			/* Group 4 */
+			if (rin->Dword & 0x0000f000) {
+				found4 = false;
+			} else {
+				found4 = true;
+			}
+
+			if (found1 && found2 && found3 && found4) {
+				zlist = talloc_realloc(mem_ctx, zlist, struct dnsserver_zone *, zcount+1);
+				zlist[zcount] = z;
+				zcount++;
+			}
+		}
+
+		if (client_version == DNS_CLIENT_VERSION_W2K) {
+			*typeid_out = DNSSRV_TYPEID_ZONE_LIST_W2K;
+			rout->ZoneListW2K = talloc_zero(mem_ctx, struct DNS_RPC_ZONE_LIST_W2K);
+
+			if (zcount == 0) {
+				rout->ZoneListW2K->dwZoneCount = 0;
+				rout->ZoneListW2K->ZoneArray = NULL;
+
+				return WERR_OK;
+			}
+
+			rout->ZoneListW2K->ZoneArray = talloc_zero_array(mem_ctx, struct DNS_RPC_ZONE_W2K *, zcount);
+			W_ERROR_HAVE_NO_MEMORY_AND_FREE(rout->ZoneListW2K->ZoneArray, zlist);
+
+			for (i=0; i<zcount; i++) {
+				rout->ZoneListW2K->ZoneArray[i] = talloc_zero(mem_ctx, struct DNS_RPC_ZONE_W2K);
+
+				rout->ZoneListW2K->ZoneArray[i]->pszZoneName = talloc_strdup(mem_ctx, zlist[i]->name);
+				rout->ZoneListW2K->ZoneArray[i]->Flags = zlist[i]->zoneinfo->Flags;
+				rout->ZoneListW2K->ZoneArray[i]->ZoneType = zlist[i]->zoneinfo->dwZoneType;
+				rout->ZoneListW2K->ZoneArray[i]->Version = zlist[i]->zoneinfo->Version;
+			}
+			rout->ZoneListW2K->dwZoneCount = zcount;
+
+		} else {
+			*typeid_out = DNSSRV_TYPEID_ZONE_LIST;
+			rout->ZoneList = talloc_zero(mem_ctx, struct DNS_RPC_ZONE_LIST_DOTNET);
+
+			if (zcount == 0) {
+				rout->ZoneList->dwRpcStructureVersion = 1;
+				rout->ZoneList->dwZoneCount = 0;
+				rout->ZoneList->ZoneArray = NULL;
+
+				return WERR_OK;
+			}
+
+			rout->ZoneList->ZoneArray = talloc_zero_array(mem_ctx, struct DNS_RPC_ZONE_DOTNET *, zcount);
+			W_ERROR_HAVE_NO_MEMORY_AND_FREE(rout->ZoneList->ZoneArray, zlist);
+
+			for (i=0; i<zcount; i++) {
+				rout->ZoneList->ZoneArray[i] = talloc_zero(mem_ctx, struct DNS_RPC_ZONE_DOTNET);
+
+				rout->ZoneList->ZoneArray[i]->dwRpcStructureVersion = 1;
+				rout->ZoneList->ZoneArray[i]->pszZoneName = talloc_strdup(mem_ctx, zlist[i]->name);
+				rout->ZoneList->ZoneArray[i]->Flags = zlist[i]->zoneinfo->Flags;
+				rout->ZoneList->ZoneArray[i]->ZoneType = zlist[i]->zoneinfo->dwZoneType;
+				rout->ZoneList->ZoneArray[i]->Version = zlist[i]->zoneinfo->Version;
+				rout->ZoneList->ZoneArray[i]->dwDpFlags = zlist[i]->partition->dwDpFlags;
+				rout->ZoneList->ZoneArray[i]->pszDpFqdn = talloc_strdup(mem_ctx, zlist[i]->partition->pszDpFqdn);
+			}
+			rout->ZoneList->dwRpcStructureVersion = 1;
+			rout->ZoneList->dwZoneCount = zcount;
+		}
+		talloc_free(zlist);
+		return WERR_OK;
+	} else if (strcasecmp(operation, "EnumZones2") == 0) {
+		valid_operation = true;
+	} else if (strcasecmp(operation, "EnumDirectoryPartitions") == 0) {
+		if (typeid_in != DNSSRV_TYPEID_DWORD) {
+			return WERR_DNS_ERROR_INVALID_PROPERTY;
+		}
+
+		*typeid_out = DNSSRV_TYPEID_DP_LIST;
+		rout->DirectoryPartitionList = talloc_zero(mem_ctx, struct DNS_RPC_DP_LIST);
+
+		if (rin->Dword != 0) {
+			rout->DirectoryPartitionList->dwDpCount = 0;
+			rout->DirectoryPartitionList->DpArray = NULL;
+		} else {
+			struct DNS_RPC_DP_ENUM **dplist;
+			struct dnsserver_partition *p;
+			int pcount = 2;
+
+			dplist = talloc_zero_array(mem_ctx, struct DNS_RPC_DP_ENUM *, pcount);
+			W_ERROR_HAVE_NO_MEMORY(dplist);
+
+			p = dsstate->partitions;
+			for (i=0; i<pcount; i++) {
+				dplist[i] = talloc_zero(dplist, struct DNS_RPC_DP_ENUM);
+
+				dplist[i]->pszDpFqdn = talloc_strdup(mem_ctx, p->pszDpFqdn);
+				dplist[i]->dwFlags = p->dwDpFlags;
+				dplist[i]->dwZoneCount = p->zones_count;
+				p = p->next;
+			}
+
+			rout->DirectoryPartitionList->dwDpCount = pcount;
+			rout->DirectoryPartitionList->DpArray = dplist;
+		}
+		return WERR_OK;
+	} else if (strcasecmp(operation, "DirectoryPartitionInfo") == 0) {
+		struct dnsserver_partition *p;
+		struct dnsserver_partition_info *partinfo;
+		struct DNS_RPC_DP_INFO *dpinfo = NULL;
+
+		if (typeid_in != DNSSRV_TYPEID_LPSTR) {
+			return WERR_DNS_ERROR_INVALID_PROPERTY;
+		}
+
+		*typeid_out = DNSSRV_TYPEID_DP_INFO;
+
+		for (p = dsstate->partitions; p; p = p->next) {
+			if (strcasecmp(p->pszDpFqdn, rin->String) == 0) {
+				dpinfo = talloc_zero(mem_ctx, struct DNS_RPC_DP_INFO);
+				W_ERROR_HAVE_NO_MEMORY(dpinfo);
+
+				partinfo = dnsserver_db_partition_info(mem_ctx, dsstate->samdb, p);
+				W_ERROR_HAVE_NO_MEMORY(partinfo);
+
+				dpinfo->pszDpFqdn = talloc_strdup(dpinfo, p->pszDpFqdn);
+				dpinfo->pszDpDn = talloc_strdup(dpinfo, ldb_dn_get_linearized(p->partition_dn));
+				dpinfo->pszCrDn = talloc_steal(dpinfo, partinfo->pszCrDn);
+				dpinfo->dwFlags = p->dwDpFlags;
+				dpinfo->dwZoneCount = p->zones_count;
+				dpinfo->dwState = partinfo->dwState;
+				dpinfo->dwReplicaCount = partinfo->dwReplicaCount;
+				if (partinfo->dwReplicaCount > 0) {
+					dpinfo->ReplicaArray = talloc_steal(dpinfo,
+									    partinfo->ReplicaArray);
+				} else {
+					dpinfo->ReplicaArray = NULL;
+				}
+				break;
+			}
+		}
+
+		if (dpinfo == NULL) {
+			return WERR_DNS_ERROR_DP_DOES_NOT_EXIST;
+		}
+
+		rout->DirectoryPartition = dpinfo;
+		return WERR_OK;
+	} else if (strcasecmp(operation, "Statistics") == 0) {
+		valid_operation = true;
+	} else if (strcasecmp(operation, "IpValidate") == 0) {
+		valid_operation = true;
+	}
+
+	if (valid_operation) {
+		DEBUG(0, ("dnsserver: server complex operation '%s' not implemented", operation));
+		return WERR_CALL_NOT_IMPLEMENTED;
+	}
+
+	DEBUG(0, ("dnsserver: invalid server complex operation '%s'", operation));
+	return WERR_DNS_ERROR_INVALID_PROPERTY;
+}
+
+/* [MS-DNSP].pdf Section 3.1.1.2 Zone Configuration Information */
+static WERROR dnsserver_operate_zone(struct dnsserver_state *dsstate,
+					TALLOC_CTX *mem_ctx,
+					struct dnsserver_zone *z,
+					unsigned int request_filter,
+					const char *operation,
+					const unsigned int client_version,
+					enum DNS_RPC_TYPEID typeid,
+					union DNSSRV_RPC_UNION *r)
+{
+	bool valid_operation = false;
+
+	if (strcasecmp(operation, "ResetDwordProperty") == 0) {
+
+		if (typeid != DNSSRV_TYPEID_NAME_AND_PARAM) {
+			return WERR_DNS_ERROR_INVALID_PROPERTY;
+		}
+
+		return dnsserver_db_do_reset_dword(dsstate->samdb, z,
+					           r->NameAndParam);
+
+	} else if (strcasecmp(operation, "ZoneTypeReset") == 0) {
+		valid_operation = true;
+	} else if (strcasecmp(operation, "PauseZone") == 0) {
+		valid_operation = true;
+	} else if (strcasecmp(operation, "ResumeZone") == 0) {
+		valid_operation = true;
+	} else if (strcasecmp(operation, "DeleteZone") == 0) {
+		valid_operation = true;
+	} else if (strcasecmp(operation, "ReloadZone") == 0) {
+		valid_operation = true;
+	} else if (strcasecmp(operation, "RefreshZone") == 0) {
+		valid_operation = true;
+	} else if (strcasecmp(operation, "ExpireZone") == 0) {
+		valid_operation = true;
+	} else if (strcasecmp(operation, "IncrementVersion") == 0) {
+		valid_operation = true;
+	} else if (strcasecmp(operation, "WriteBackFile") == 0) {
+		valid_operation = true;
+	} else if (strcasecmp(operation, "DeleteZoneFromDs") == 0) {
+		WERROR status;
+		if (z == NULL) {
+			return WERR_DNS_ERROR_ZONE_DOES_NOT_EXIST;
+		}
+		status =  dnsserver_db_delete_zone(dsstate->samdb, z);
+		if (W_ERROR_IS_OK(status)) {
+			dnsserver_reload_zones(dsstate);
+		}
+		return status;
+	} else if (strcasecmp(operation, "UpdateZoneFromDs") == 0) {
+		valid_operation = true;
+	} else if (strcasecmp(operation, "ZoneExport") == 0) {
+		valid_operation = true;
+	} else if (strcasecmp(operation, "ZoneChangeDirectoryPartition") == 0) {
+		valid_operation = true;
+	} else if (strcasecmp(operation, "DeleteNode") == 0) {
+		valid_operation = true;
+	} else if (strcasecmp(operation, "DeleteRecordSet") == 0) {
+		valid_operation = true;
+	} else if (strcasecmp(operation, "ForceAgingOnNode") == 0) {
+		valid_operation = true;
+	} else if (strcasecmp(operation, "DatabaseFile") == 0) {
+		valid_operation = true;
+	} else if (strcasecmp(operation, "MasterServers") == 0) {
+		valid_operation = true;
+	} else if (strcasecmp(operation, "LocalMasterServers") == 0) {
+		valid_operation = true;
+	} else if (strcasecmp(operation, "NotifyServers") == 0) {
+		valid_operation = true;
+	} else if (strcasecmp(operation, "SecondaryServers") == 0) {
+		valid_operation = true;
+	} else if (strcasecmp(operation, "ScavengingServers") == 0) {
+		valid_operation = true;
+	} else if (strcasecmp(operation, "AllowNSRecordsAutoCreation") == 0) {
+		valid_operation = true;
+	} else if (strcasecmp(operation, "BreakOnNameUpdate") == 0) {
+		valid_operation = true;
+	} else if (strcasecmp(operation, "ApplicationDirectoryPartition") == 0) {
+		valid_operation = true;
+	}
+
+	if (valid_operation) {
+		DEBUG(0, ("dnsserver: zone operation '%s' not implemented", operation));
+		return WERR_CALL_NOT_IMPLEMENTED;
+	}
+
+	DEBUG(0, ("dnsserver: invalid zone operation '%s'", operation));
+	return WERR_DNS_ERROR_INVALID_PROPERTY;
+}
+
+static WERROR dnsserver_complex_operate_zone(struct dnsserver_state *dsstate,
+					TALLOC_CTX *mem_ctx,
+					struct dnsserver_zone *z,
+					const char *operation,
+					const unsigned int client_version,
+					enum DNS_RPC_TYPEID typeid_in,
+					union DNSSRV_RPC_UNION *rin,
+					enum DNS_RPC_TYPEID *typeid_out,
+					union DNSSRV_RPC_UNION *rout)
+{
+	if (strcasecmp(operation, "QueryDwordProperty") == 0) {
+		if (typeid_in == DNSSRV_TYPEID_LPSTR) {
+			return dnsserver_query_zone(dsstate, mem_ctx, z,
+						rin->String,
+						client_version,
+						typeid_out,
+						rout);
+
+		}
+	}
+
+	DEBUG(0,("dnsserver: Invalid zone operation %s", operation));
+	return WERR_DNS_ERROR_INVALID_PROPERTY;
+}
+
+/* dnsserver enumerate function */
+
+static WERROR dnsserver_enumerate_root_records(struct dnsserver_state *dsstate,
+					TALLOC_CTX *mem_ctx,
+					unsigned int client_version,
+					const char *node_name,
+					enum dns_record_type record_type,
+					unsigned int select_flag,
+					unsigned int *buffer_length,
+					struct DNS_RPC_RECORDS_ARRAY **buffer)
+{
+	TALLOC_CTX *tmp_ctx;
+	struct dnsserver_zone *z;
+	const char * const attrs[] = { "name", "dnsRecord", NULL };
+	struct ldb_result *res;
+	struct DNS_RPC_RECORDS_ARRAY *recs;
+	char **add_names;
+	char *rname;
+	int add_count;
+	int i, ret, len;
+	WERROR status;
+
+	tmp_ctx = talloc_new(mem_ctx);
+	W_ERROR_HAVE_NO_MEMORY(tmp_ctx);
+
+	z = dnsserver_find_zone(dsstate->zones, ".");
+	if (z == NULL) {
+		return WERR_DNS_ERROR_NAME_DOES_NOT_EXIST;
+	}
+
+	ret = ldb_search(dsstate->samdb, tmp_ctx, &res, z->zone_dn,
+			 LDB_SCOPE_ONELEVEL, attrs,
+			 "(&(objectClass=dnsNode)(name=@)(!(dNSTombstoned=TRUE)))");
+	if (ret != LDB_SUCCESS) {
+		talloc_free(tmp_ctx);
+		return WERR_INTERNAL_DB_ERROR;
+	}
+	if (res->count == 0) {
+		talloc_free(tmp_ctx);
+		return WERR_DNS_ERROR_NAME_DOES_NOT_EXIST;
+	}
+
+	recs = talloc_zero(mem_ctx, struct DNS_RPC_RECORDS_ARRAY);
+	W_ERROR_HAVE_NO_MEMORY_AND_FREE(recs, tmp_ctx);
+
+	add_names = NULL;
+	add_count = 0;
+
+	for (i=0; i<res->count; i++) {
+		status = dns_fill_records_array(tmp_ctx, NULL, record_type,
+						select_flag, NULL,
+						res->msgs[i], 0, recs,
+						&add_names, &add_count);
+		if (!W_ERROR_IS_OK(status)) {
+			talloc_free(tmp_ctx);
+			return status;
+		}
+	}
+	talloc_free(res);
+
+	/* Add any additional records */
+	if (select_flag & DNS_RPC_VIEW_ADDITIONAL_DATA) {
+		for (i=0; i<add_count; i++) {
+			char *encoded_name
+				= ldb_binary_encode_string(tmp_ctx,
+							   add_names[i]);
+			ret = ldb_search(dsstate->samdb, tmp_ctx, &res, z->zone_dn,
+					 LDB_SCOPE_ONELEVEL, attrs,
+					 "(&(objectClass=dnsNode)(name=%s)(!(dNSTombstoned=TRUE)))",
+					 encoded_name);
+			if (ret != LDB_SUCCESS || res->count == 0) {
+				talloc_free(res);
+				continue;
+			}
+
+			len = strlen(add_names[i]);
+			if (add_names[i][len-1] == '.') {
+				rname = talloc_strdup(tmp_ctx, add_names[i]);
+			} else {
+				rname = talloc_asprintf(tmp_ctx, "%s.", add_names[i]);
+			}
+			status = dns_fill_records_array(tmp_ctx, NULL, DNS_TYPE_A,
+							select_flag, rname,
+							res->msgs[0], 0, recs,
+							NULL, NULL);
+			talloc_free(rname);
+			talloc_free(res);
+			if (!W_ERROR_IS_OK(status)) {
+				talloc_free(tmp_ctx);
+				return status;
+			}
+		}
+	}
+
+	talloc_free(tmp_ctx);
+
+	*buffer_length = ndr_size_DNS_RPC_RECORDS_ARRAY(recs, 0);
+	*buffer = recs;
+
+	return WERR_OK;
+}
+
+
+static WERROR dnsserver_enumerate_records(struct dnsserver_state *dsstate,
+					TALLOC_CTX *mem_ctx,
+					struct dnsserver_zone *z,
+					unsigned int client_version,
+					const char *node_name,
+					const char *start_child,
+					enum dns_record_type record_type,
+					unsigned int select_flag,
+					const char *filter_start,
+					const char *filter_stop,
+					unsigned int *buffer_length,
+					struct DNS_RPC_RECORDS_ARRAY **buffer)
+{
+	TALLOC_CTX *tmp_ctx;
+	char *name;
+	const char * const attrs[] = { "name", "dnsRecord", NULL };
+	struct ldb_result *res = NULL;
+	struct DNS_RPC_RECORDS_ARRAY *recs = NULL;
+	char **add_names = NULL;
+	char *rname = NULL;
+	const char *preference_name = NULL;
+	int add_count = 0;
+	int i, ret, len;
+	WERROR status;
+	struct dns_tree *tree = NULL;
+	struct dns_tree *base = NULL;
+	struct dns_tree *node = NULL;
+
+	tmp_ctx = talloc_new(mem_ctx);
+	W_ERROR_HAVE_NO_MEMORY(tmp_ctx);
+
+	name = dns_split_node_name(tmp_ctx, node_name, z->name);
+	W_ERROR_HAVE_NO_MEMORY_AND_FREE(name, tmp_ctx);
+
+	/* search all records under parent tree */
+	if (strcasecmp(name, z->name) == 0) {
+		ret = ldb_search(dsstate->samdb, tmp_ctx, &res, z->zone_dn,
+				 LDB_SCOPE_ONELEVEL, attrs,
+				 "(&(objectClass=dnsNode)(!(dNSTombstoned=TRUE)))");
+		preference_name = "@";
+	} else {
+		char *encoded_name
+			= ldb_binary_encode_string(tmp_ctx, name);
+		ret = ldb_search(dsstate->samdb, tmp_ctx, &res, z->zone_dn,
+				 LDB_SCOPE_ONELEVEL, attrs,
+				 "(&(objectClass=dnsNode)(|(name=%s)(name=*.%s))(!(dNSTombstoned=TRUE)))",
+				 encoded_name, encoded_name);
+		preference_name = name;
+	}
+	if (ret != LDB_SUCCESS) {
+		talloc_free(tmp_ctx);
+		return WERR_INTERNAL_DB_ERROR;
+	}
+	if (res->count == 0) {
+		talloc_free(tmp_ctx);
+		return WERR_DNS_ERROR_NAME_DOES_NOT_EXIST;
+	}
+
+	recs = talloc_zero(mem_ctx, struct DNS_RPC_RECORDS_ARRAY);
+	W_ERROR_HAVE_NO_MEMORY_AND_FREE(recs, tmp_ctx);
+
+	/*
+	 * Sort the names, so that the records are in order by the child
+	 * component below "name".
+	 *
+	 * A full tree sort is not required, so we pass in "name" so
+	 * we know which level to sort, as only direct children are
+	 * eventually returned
+	 */
+	LDB_TYPESAFE_QSORT(res->msgs, res->count, name, dns_name_compare);
+
+	/* Build a tree of name components from dns name */
+	tree = dns_build_tree(tmp_ctx, preference_name, res);
+	W_ERROR_HAVE_NO_MEMORY_AND_FREE(tree, tmp_ctx);
+
+	/* Find the parent record in the tree */
+	base = tree;
+	while (base->level != -1) {
+		base = base->children[0];
+	}
+
+	/* Add the parent record with blank name */
+	if (!(select_flag & DNS_RPC_VIEW_ONLY_CHILDREN)) {
+		status = dns_fill_records_array(tmp_ctx, z, record_type,
+						select_flag, NULL,
+						base->data, 0,
+						recs, &add_names, &add_count);
+		if (!W_ERROR_IS_OK(status)) {
+			talloc_free(tmp_ctx);
+			return status;
+		}
+	}
+
+	/* Add all the children records */
+	if (!(select_flag & DNS_RPC_VIEW_NO_CHILDREN)) {
+		for (i=0; i<base->num_children; i++) {
+			node = base->children[i];
+
+			status = dns_fill_records_array(tmp_ctx, z, record_type,
+							select_flag, node->name,
+							node->data, node->num_children,
+							recs, &add_names, &add_count);
+			if (!W_ERROR_IS_OK(status)) {
+				talloc_free(tmp_ctx);
+				return status;
+			}
+		}
+	}
+
+	TALLOC_FREE(res);
+	TALLOC_FREE(tree);
+	TALLOC_FREE(name);
+
+	/* Add any additional records */
+	if (select_flag & DNS_RPC_VIEW_ADDITIONAL_DATA) {
+		for (i=0; i<add_count; i++) {
+			struct dnsserver_zone *z2 = NULL;
+			struct ldb_message *msg = NULL;
+			/* Search all the available zones for additional name */
+			for (z2 = dsstate->zones; z2; z2 = z2->next) {
+				char *encoded_name;
+				name = dns_split_node_name(tmp_ctx, add_names[i], z2->name);
+				encoded_name
+					= ldb_binary_encode_string(tmp_ctx,
+								   name);
+				ret = ldb_search(dsstate->samdb, tmp_ctx, &res, z2->zone_dn,
+						LDB_SCOPE_ONELEVEL, attrs,
+						"(&(objectClass=dnsNode)(name=%s)(!(dNSTombstoned=TRUE)))",
+						encoded_name);
+				TALLOC_FREE(name);
+				if (ret != LDB_SUCCESS) {
+					continue;
+				}
+				if (res->count == 1) {
+					msg = res->msgs[0];
+					break;
+				} else {
+					TALLOC_FREE(res);
+					continue;
+				}
+			}
+
+			len = strlen(add_names[i]);
+			if (add_names[i][len-1] == '.') {
+				rname = talloc_strdup(tmp_ctx, add_names[i]);
+			} else {
+				rname = talloc_asprintf(tmp_ctx, "%s.", add_names[i]);
+			}
+			status = dns_fill_records_array(tmp_ctx, NULL, DNS_TYPE_A,
+							select_flag, rname,
+							msg, 0, recs,
+							NULL, NULL);
+			TALLOC_FREE(rname);
+			TALLOC_FREE(res);
+			if (!W_ERROR_IS_OK(status)) {
+				talloc_free(tmp_ctx);
+				return status;
+			}
+		}
+	}
+
+	*buffer_length = ndr_size_DNS_RPC_RECORDS_ARRAY(recs, 0);
+	*buffer = recs;
+
+	return WERR_OK;
+}
+
+/*
+ * Check str1 + '.' + str2 = name, for example:
+ * ("dc0", "example.com", "dc0.example.com") = true
+ */
+static bool cname_self_reference(const char* node_name,
+				 const char* zone_name,
+				 struct DNS_RPC_NAME name) {
+	size_t node_len, zone_len;
+
+	if (node_name == NULL || zone_name == NULL) {
+		return false;
+	}
+
+	node_len = strlen(node_name);
+	zone_len = strlen(zone_name);
+
+	if (node_len == 0 ||
+	    zone_len == 0 ||
+	    (name.len != node_len + zone_len + 1)) {
+		return false;
+	}
+
+	if (strncmp(node_name, name.str, node_len) == 0 &&
+	    name.str[node_len] == '.' &&
+	    strncmp(zone_name, name.str + node_len + 1, zone_len) == 0) {
+		return true;
+	}
+
+	return false;
+}
+
+/* dnsserver update function */
+
+static WERROR dnsserver_update_record(struct dnsserver_state *dsstate,
+					TALLOC_CTX *mem_ctx,
+					struct dnsserver_zone *z,
+					unsigned int client_version,
+					const char *node_name,
+					struct DNS_RPC_RECORD_BUF *add_buf,
+					struct DNS_RPC_RECORD_BUF *del_buf)
+{
+	TALLOC_CTX *tmp_ctx;
+	char *name;
+	WERROR status;
+
+	tmp_ctx = talloc_new(mem_ctx);
+	W_ERROR_HAVE_NO_MEMORY(tmp_ctx);
+
+	/* If node_name is @ or zone name, dns record is @ */
+	if (strcmp(node_name, "@") == 0 ||
+	    strcmp(node_name, ".") == 0 ||
+	    strcasecmp(node_name, z->name) == 0) {
+		name = talloc_strdup(tmp_ctx, "@");
+	} else {
+		name = dns_split_node_name(tmp_ctx, node_name, z->name);
+	}
+	W_ERROR_HAVE_NO_MEMORY_AND_FREE(name, tmp_ctx);
+
+	/* CNAMEs can't point to themselves */
+	if (add_buf != NULL && add_buf->rec.wType == DNS_TYPE_CNAME) {
+		if (cname_self_reference(node_name, z->name, add_buf->rec.data.name)) {
+			return WERR_DNS_ERROR_CNAME_LOOP;
+		}
+	}
+
+	if (add_buf != NULL) {
+		if (del_buf == NULL) {
+			/* Add record */
+			status = dnsserver_db_add_record(tmp_ctx, dsstate->samdb,
+								z, name,
+								&add_buf->rec);
+		} else {
+			/* Update record */
+			status = dnsserver_db_update_record(tmp_ctx, dsstate->samdb,
+								z, name,
+								&add_buf->rec,
+								&del_buf->rec);
+		}
+	} else {
+		if (del_buf == NULL) {
+			/* Add empty node */
+			status = dnsserver_db_add_empty_node(tmp_ctx, dsstate->samdb,
+								z, name);
+		} else {
+			/* Delete record */
+			status = dnsserver_db_delete_record(tmp_ctx, dsstate->samdb,
+								z, name,
+								&del_buf->rec);
+		}
+	}
+
+	talloc_free(tmp_ctx);
+	return status;
+}
+
+
+/* dnsserver interface functions */
+
+static WERROR dcesrv_DnssrvOperation(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, struct DnssrvOperation *r)
+{
+	struct dnsserver_state *dsstate;
+	struct dnsserver_zone *z = NULL;
+	uint32_t request_filter = 0;
+	WERROR ret;
+
+	if ((dsstate = dnsserver_connect(dce_call)) == NULL) {
+		return WERR_DNS_ERROR_DS_UNAVAILABLE;
+	}
+
+	if (r->in.dwContext == 0) {
+		if (r->in.pszZone != NULL) {
+			request_filter = dnsserver_zone_to_request_filter(r->in.pszZone);
+		}
+	} else {
+		request_filter = r->in.dwContext;
+	}
+
+	if (r->in.pszZone == NULL) {
+		ret = dnsserver_operate_server(dsstate, mem_ctx,
+						r->in.pszOperation,
+						DNS_CLIENT_VERSION_W2K,
+						r->in.dwTypeId,
+						&r->in.pData);
+	} else {
+		z = dnsserver_find_zone(dsstate->zones, r->in.pszZone);
+		/*
+		 * In the case that request_filter is not 0 and z is NULL,
+		 * the request is for a multizone operation, which we do not
+		 * yet support, so just error on NULL zone name.
+		 */
+		if (z == NULL) {
+			return WERR_DNS_ERROR_ZONE_DOES_NOT_EXIST;
+		}
+
+		ret = dnsserver_operate_zone(dsstate, mem_ctx, z,
+						request_filter,
+						r->in.pszOperation,
+						DNS_CLIENT_VERSION_W2K,
+						r->in.dwTypeId,
+						&r->in.pData);
+	}
+
+	if (W_ERROR_EQUAL(ret, WERR_CALL_NOT_IMPLEMENTED)) {
+		NDR_PRINT_FUNCTION_DEBUG(DnssrvOperation, NDR_IN, r);
+	}
+	return ret;
+}
+
+static WERROR dcesrv_DnssrvQuery(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, struct DnssrvQuery *r)
+{
+	struct dnsserver_state *dsstate;
+	struct dnsserver_zone *z;
+	WERROR ret;
+
+	ZERO_STRUCTP(r->out.pdwTypeId);
+	ZERO_STRUCTP(r->out.ppData);
+
+	if ((dsstate = dnsserver_connect(dce_call)) == NULL) {
+		return WERR_DNS_ERROR_DS_UNAVAILABLE;
+	}
+
+	if (r->in.pszZone == NULL) {
+		/* FIXME: DNS Server Configuration Access Control List */
+		ret = dnsserver_query_server(dsstate, mem_ctx,
+						r->in.pszOperation,
+						DNS_CLIENT_VERSION_W2K,
+						r->out.pdwTypeId,
+						r->out.ppData);
+	} else {
+		z = dnsserver_find_zone(dsstate->zones, r->in.pszZone);
+		if (z == NULL) {
+			return WERR_DNS_ERROR_ZONE_DOES_NOT_EXIST;
+		}
+
+		ret = dnsserver_query_zone(dsstate, mem_ctx, z,
+						r->in.pszOperation,
+						DNS_CLIENT_VERSION_W2K,
+						r->out.pdwTypeId,
+						r->out.ppData);
+	}
+
+	if (W_ERROR_EQUAL(ret, WERR_CALL_NOT_IMPLEMENTED)) {
+		NDR_PRINT_FUNCTION_DEBUG(DnssrvQuery, NDR_IN, r);
+	}
+	return ret;
+}
+
+static WERROR dcesrv_DnssrvComplexOperation(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, struct DnssrvComplexOperation *r)
+{
+	struct dnsserver_state *dsstate;
+	struct dnsserver_zone *z;
+	WERROR ret;
+
+	ZERO_STRUCTP(r->out.pdwTypeOut);
+	ZERO_STRUCTP(r->out.ppDataOut);
+
+	if ((dsstate = dnsserver_connect(dce_call)) == NULL) {
+		return WERR_DNS_ERROR_DS_UNAVAILABLE;
+	}
+
+	if (r->in.pszZone == NULL) {
+		/* Server operation */
+		ret = dnsserver_complex_operate_server(dsstate, mem_ctx,
+							r->in.pszOperation,
+							DNS_CLIENT_VERSION_W2K,
+							r->in.dwTypeIn,
+							&r->in.pDataIn,
+							r->out.pdwTypeOut,
+							r->out.ppDataOut);
+	} else {
+		z = dnsserver_find_zone(dsstate->zones, r->in.pszZone);
+		if (z == NULL) {
+			return WERR_DNS_ERROR_ZONE_DOES_NOT_EXIST;
+		}
+
+		ret = dnsserver_complex_operate_zone(dsstate, mem_ctx, z,
+							r->in.pszOperation,
+							DNS_CLIENT_VERSION_W2K,
+							r->in.dwTypeIn,
+							&r->in.pDataIn,
+							r->out.pdwTypeOut,
+							r->out.ppDataOut);
+	}
+
+	if (W_ERROR_EQUAL(ret, WERR_CALL_NOT_IMPLEMENTED)) {
+		NDR_PRINT_FUNCTION_DEBUG(DnssrvComplexOperation, NDR_IN, r);
+	}
+	return ret;
+}
+
+static WERROR dcesrv_DnssrvEnumRecords(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, struct DnssrvEnumRecords *r)
+{
+	struct dnsserver_state *dsstate;
+	struct dnsserver_zone *z;
+	WERROR ret;
+
+	ZERO_STRUCTP(r->out.pdwBufferLength);
+	ZERO_STRUCTP(r->out.pBuffer);
+
+	if ((dsstate = dnsserver_connect(dce_call)) == NULL) {
+		return WERR_DNS_ERROR_DS_UNAVAILABLE;
+	}
+
+	if (r->in.pszZone == NULL) {
+		return WERR_DNS_ERROR_NAME_DOES_NOT_EXIST;
+	}
+
+	if (strcasecmp(r->in.pszZone, "..RootHints") == 0) {
+		ret = dnsserver_enumerate_root_records(dsstate, mem_ctx,
+					DNS_CLIENT_VERSION_W2K,
+					r->in.pszNodeName,
+					r->in.wRecordType,
+					r->in.fSelectFlag,
+					r->out.pdwBufferLength,
+					r->out.pBuffer);
+	} else {
+		z = dnsserver_find_zone(dsstate->zones, r->in.pszZone);
+		if (z == NULL) {
+			return WERR_DNS_ERROR_NAME_DOES_NOT_EXIST;
+		}
+
+		ret = dnsserver_enumerate_records(dsstate, mem_ctx, z,
+					DNS_CLIENT_VERSION_W2K,
+					r->in.pszNodeName,
+					r->in.pszStartChild,
+					r->in.wRecordType,
+					r->in.fSelectFlag,
+					r->in.pszFilterStart,
+					r->in.pszFilterStop,
+					r->out.pdwBufferLength,
+					r->out.pBuffer);
+	}
+
+	if (W_ERROR_EQUAL(ret, WERR_CALL_NOT_IMPLEMENTED)) {
+		NDR_PRINT_FUNCTION_DEBUG(DnssrvEnumRecords, NDR_IN, r);
+	}
+	return ret;
+}
+
+static WERROR dcesrv_DnssrvUpdateRecord(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, struct DnssrvUpdateRecord *r)
+{
+	struct dnsserver_state *dsstate;
+	struct dnsserver_zone *z;
+	WERROR ret;
+
+	if ((dsstate = dnsserver_connect(dce_call)) == NULL) {
+		return WERR_DNS_ERROR_DS_UNAVAILABLE;
+	}
+
+	if (r->in.pszZone == NULL) {
+		return WERR_DNS_ERROR_NAME_DOES_NOT_EXIST;
+	}
+
+	z = dnsserver_find_zone(dsstate->zones, r->in.pszZone);
+	if (z == NULL) {
+		return WERR_DNS_ERROR_NAME_DOES_NOT_EXIST;
+	}
+
+	ret = dnsserver_update_record(dsstate, mem_ctx, z,
+					DNS_CLIENT_VERSION_W2K,
+					r->in.pszNodeName,
+					r->in.pAddRecord,
+					r->in.pDeleteRecord);
+
+	if (W_ERROR_EQUAL(ret, WERR_CALL_NOT_IMPLEMENTED)) {
+		NDR_PRINT_FUNCTION_DEBUG(DnssrvUpdateRecord, NDR_IN, r);
+	}
+	return ret;
+}
+
+static WERROR dcesrv_DnssrvOperation2(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, struct DnssrvOperation2 *r)
+{
+	struct dnsserver_state *dsstate;
+	struct dnsserver_zone *z = NULL;
+	uint32_t request_filter = 0;
+	WERROR ret;
+
+	if ((dsstate = dnsserver_connect(dce_call)) == NULL) {
+		return WERR_DNS_ERROR_DS_UNAVAILABLE;
+	}
+
+	if (r->in.dwContext == 0) {
+		if (r->in.pszZone != NULL) {
+			request_filter = dnsserver_zone_to_request_filter(r->in.pszZone);
+		}
+	} else {
+		request_filter = r->in.dwContext;
+	}
+
+	if (r->in.pszZone == NULL) {
+		ret = dnsserver_operate_server(dsstate, mem_ctx,
+						r->in.pszOperation,
+						r->in.dwClientVersion,
+						r->in.dwTypeId,
+						&r->in.pData);
+	} else {
+		z = dnsserver_find_zone(dsstate->zones, r->in.pszZone);
+		/*
+		 * In the case that request_filter is not 0 and z is NULL,
+		 * the request is for a multizone operation, which we do not
+		 * yet support, so just error on NULL zone name.
+		 */
+		if (z == NULL) {
+			return WERR_DNS_ERROR_ZONE_DOES_NOT_EXIST;
+		}
+
+		ret = dnsserver_operate_zone(dsstate, mem_ctx, z,
+						request_filter,
+						r->in.pszOperation,
+						r->in.dwClientVersion,
+						r->in.dwTypeId,
+						&r->in.pData);
+	}
+
+	if (W_ERROR_EQUAL(ret, WERR_CALL_NOT_IMPLEMENTED)) {
+		NDR_PRINT_FUNCTION_DEBUG(DnssrvOperation2, NDR_IN, r);
+	}
+	return ret;
+}
+
+static WERROR dcesrv_DnssrvQuery2(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, struct DnssrvQuery2 *r)
+{
+	struct dnsserver_state *dsstate;
+	struct dnsserver_zone *z;
+	WERROR ret;
+
+	ZERO_STRUCTP(r->out.pdwTypeId);
+	ZERO_STRUCTP(r->out.ppData);
+
+	if ((dsstate = dnsserver_connect(dce_call)) == NULL) {
+		return WERR_DNS_ERROR_DS_UNAVAILABLE;
+	}
+
+	if (r->in.pszZone == NULL) {
+		/* FIXME: DNS Server Configuration Access Control List */
+		ret = dnsserver_query_server(dsstate, mem_ctx,
+						r->in.pszOperation,
+						r->in.dwClientVersion,
+						r->out.pdwTypeId,
+						r->out.ppData);
+	} else {
+		z = dnsserver_find_zone(dsstate->zones, r->in.pszZone);
+		if (z == NULL) {
+			return WERR_DNS_ERROR_ZONE_DOES_NOT_EXIST;
+		}
+
+		ret = dnsserver_query_zone(dsstate, mem_ctx, z,
+					r->in.pszOperation,
+					r->in.dwClientVersion,
+					r->out.pdwTypeId,
+					r->out.ppData);
+	}
+
+	if (W_ERROR_EQUAL(ret, WERR_CALL_NOT_IMPLEMENTED)) {
+		NDR_PRINT_FUNCTION_DEBUG(DnssrvQuery2, NDR_IN, r);
+	}
+	return ret;
+}
+
+static WERROR dcesrv_DnssrvComplexOperation2(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, struct DnssrvComplexOperation2 *r)
+{
+	struct dnsserver_state *dsstate;
+	struct dnsserver_zone *z;
+	WERROR ret;
+
+	ZERO_STRUCTP(r->out.pdwTypeOut);
+	ZERO_STRUCTP(r->out.ppDataOut);
+
+	if ((dsstate = dnsserver_connect(dce_call)) == NULL) {
+		return WERR_DNS_ERROR_DS_UNAVAILABLE;
+	}
+
+	if (r->in.pszZone == NULL) {
+		/* Server operation */
+		ret =  dnsserver_complex_operate_server(dsstate, mem_ctx,
+							r->in.pszOperation,
+							r->in.dwClientVersion,
+							r->in.dwTypeIn,
+							&r->in.pDataIn,
+							r->out.pdwTypeOut,
+							r->out.ppDataOut);
+	} else {
+
+		z = dnsserver_find_zone(dsstate->zones, r->in.pszZone);
+		if (z == NULL) {
+			return WERR_DNS_ERROR_ZONE_DOES_NOT_EXIST;
+		}
+
+		ret = dnsserver_complex_operate_zone(dsstate, mem_ctx, z,
+							r->in.pszOperation,
+							r->in.dwClientVersion,
+							r->in.dwTypeIn,
+							&r->in.pDataIn,
+							r->out.pdwTypeOut,
+							r->out.ppDataOut);
+	}
+
+	if (W_ERROR_EQUAL(ret, WERR_CALL_NOT_IMPLEMENTED)) {
+		NDR_PRINT_FUNCTION_DEBUG(DnssrvComplexOperation2, NDR_IN, r);
+	}
+	return ret;
+}
+
+static WERROR dcesrv_DnssrvEnumRecords2(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, struct DnssrvEnumRecords2 *r)
+{
+	struct dnsserver_state *dsstate;
+	struct dnsserver_zone *z;
+	WERROR ret;
+
+	ZERO_STRUCTP(r->out.pdwBufferLength);
+	ZERO_STRUCTP(r->out.pBuffer);
+
+	if ((dsstate = dnsserver_connect(dce_call)) == NULL) {
+		return WERR_DNS_ERROR_DS_UNAVAILABLE;
+	}
+
+	if (r->in.pszZone == NULL) {
+		return WERR_DNS_ERROR_NAME_DOES_NOT_EXIST;
+	}
+
+	if (strcasecmp(r->in.pszZone, "..RootHints") == 0) {
+		ret =  dnsserver_enumerate_root_records(dsstate, mem_ctx,
+					r->in.dwClientVersion,
+					r->in.pszNodeName,
+					r->in.wRecordType,
+					r->in.fSelectFlag,
+					r->out.pdwBufferLength,
+					r->out.pBuffer);
+	} else {
+		z = dnsserver_find_zone(dsstate->zones, r->in.pszZone);
+		if (z == NULL) {
+			return WERR_DNS_ERROR_NAME_DOES_NOT_EXIST;
+		}
+
+		ret =  dnsserver_enumerate_records(dsstate, mem_ctx, z,
+					r->in.dwClientVersion,
+					r->in.pszNodeName,
+					r->in.pszStartChild,
+					r->in.wRecordType,
+					r->in.fSelectFlag,
+					r->in.pszFilterStart,
+					r->in.pszFilterStop,
+					r->out.pdwBufferLength,
+					r->out.pBuffer);
+
+	}
+
+	if (W_ERROR_EQUAL(ret, WERR_CALL_NOT_IMPLEMENTED)) {
+		NDR_PRINT_FUNCTION_DEBUG(DnssrvEnumRecords2, NDR_IN, r);
+	}
+	return ret;
+}
+
+static WERROR dcesrv_DnssrvUpdateRecord2(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, struct DnssrvUpdateRecord2 *r)
+{
+	struct dnsserver_state *dsstate;
+	struct dnsserver_zone *z;
+	WERROR ret;
+
+	if ((dsstate = dnsserver_connect(dce_call)) == NULL) {
+		return WERR_DNS_ERROR_DS_UNAVAILABLE;
+	}
+
+	if (r->in.pszZone == NULL) {
+		return WERR_DNS_ERROR_NAME_DOES_NOT_EXIST;
+	}
+
+	z = dnsserver_find_zone(dsstate->zones, r->in.pszZone);
+	if (z == NULL) {
+		return WERR_DNS_ERROR_NAME_DOES_NOT_EXIST;
+	}
+
+	ret = dnsserver_update_record(dsstate, mem_ctx, z,
+					r->in.dwClientVersion,
+					r->in.pszNodeName,
+					r->in.pAddRecord,
+					r->in.pDeleteRecord);
+
+	if (W_ERROR_EQUAL(ret, WERR_CALL_NOT_IMPLEMENTED)) {
+		NDR_PRINT_FUNCTION_DEBUG(DnssrvUpdateRecord2, NDR_IN, r);
+	}
+	return ret;
+}
+
+/* include the generated boilerplate */
+#include "librpc/gen_ndr/ndr_dnsserver_s.c"
diff --git a/source4/rpc_server/dnsserver/dnsdata.c b/source4/rpc_server/dnsserver/dnsdata.c
new file mode 100644
index 0000000..002d9e6
--- /dev/null
+++ b/source4/rpc_server/dnsserver/dnsdata.c
@@ -0,0 +1,1121 @@
+/*
+   Unix SMB/CIFS implementation.
+
+   DNS Server
+
+   Copyright (C) Amitay Isaacs 2011
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "includes.h"
+#include "dnsserver.h"
+#include "dns_server/dnsserver_common.h"
+#include "lib/replace/system/network.h"
+#include "librpc/gen_ndr/ndr_dnsp.h"
+#include "librpc/gen_ndr/ndr_dnsserver.h"
+
+#undef strcasecmp
+
+struct IP4_ARRAY *ip4_array_copy(TALLOC_CTX *mem_ctx, struct IP4_ARRAY *ip4)
+{
+	struct IP4_ARRAY *ret;
+
+	if (!ip4) {
+		return NULL;
+	}
+
+	ret = talloc_zero(mem_ctx, struct IP4_ARRAY);
+	if (!ret) {
+		return ret;
+	}
+
+	ret->AddrCount = ip4->AddrCount;
+	if (ip4->AddrCount > 0) {
+		ret->AddrArray = talloc_zero_array(mem_ctx, unsigned int, ip4->AddrCount);
+		if (ret->AddrArray) {
+			memcpy(ret->AddrArray, ip4->AddrArray,
+				sizeof(unsigned int) * ip4->AddrCount);
+		} else {
+			talloc_free(ret);
+			return NULL;
+		}
+	}
+	return ret;
+}
+
+
+struct DNS_ADDR_ARRAY *ip4_array_to_dns_addr_array(TALLOC_CTX *mem_ctx,
+							struct IP4_ARRAY *ip4)
+{
+	struct DNS_ADDR_ARRAY *ret;
+	int i;
+
+	if (!ip4) {
+		return NULL;
+	}
+
+	ret = talloc_zero(mem_ctx, struct DNS_ADDR_ARRAY);
+	if (!ret) {
+		return ret;
+	}
+
+	ret->MaxCount = ip4->AddrCount;
+	ret->AddrCount = ip4->AddrCount;
+	ret->Family = AF_INET;
+	if (ip4->AddrCount > 0) {
+		ret->AddrArray = talloc_zero_array(mem_ctx, struct DNS_ADDR, ip4->AddrCount);
+		if (ret->AddrArray) {
+			for (i=0; i<ip4->AddrCount; i++) {
+				ret->AddrArray[i].MaxSa[0] = 0x02;
+				ret->AddrArray[i].MaxSa[3] = 53;
+				memcpy(&ret->AddrArray[i].MaxSa[4], ip4->AddrArray,
+					sizeof(unsigned int));
+				ret->AddrArray[i].DnsAddrUserDword[0] = 6;
+			}
+
+		} else {
+			talloc_free(ret);
+			return NULL;
+		}
+	}
+	return ret;
+}
+
+struct IP4_ARRAY *dns_addr_array_to_ip4_array(TALLOC_CTX *mem_ctx,
+					      struct DNS_ADDR_ARRAY *ip)
+{
+	struct IP4_ARRAY *ret;
+	size_t i, count, curr;
+
+	if (ip == NULL) {
+		return NULL;
+	}
+	/* We must only return IPv4 addresses.
+	   The passed DNS_ADDR_ARRAY may contain:
+	   - only ipv4 addresses
+	   - only ipv6 addresses
+	   - a mixture of both
+	   - an empty array
+	*/
+	ret = talloc_zero(mem_ctx, struct IP4_ARRAY);
+	if (!ret) {
+		return ret;
+	}
+	if (ip->AddrCount == 0 || ip->Family == AF_INET6) {
+		ret->AddrCount = 0;
+		return ret;
+	}
+	/* Now only ipv4 addresses or a mixture are left */
+	count = 0;
+	for (i = 0; i < ip->AddrCount; i++) {
+		if (ip->AddrArray[i].MaxSa[0] == 0x02) {
+			/* Is ipv4 */
+			count++;
+		}
+	}
+	if (count == 0) {
+		/* should not happen */
+		ret->AddrCount = 0;
+		return ret;
+	}
+	ret->AddrArray = talloc_zero_array(mem_ctx, uint32_t, count);
+	if (ret->AddrArray) {
+		curr = 0;
+		for (i = 0; i < ip->AddrCount; i++) {
+			if (ip->AddrArray[i].MaxSa[0] == 0x02) {
+				/* Is ipv4 */
+				memcpy(&ret->AddrArray[curr],
+				       &ip->AddrArray[i].MaxSa[4],
+				       sizeof(uint32_t));
+				curr++;
+			}
+		}
+	} else {
+		talloc_free(ret);
+		return NULL;
+	}
+	ret->AddrCount = curr;
+	return ret;
+}
+
+struct DNS_ADDR_ARRAY *dns_addr_array_copy(TALLOC_CTX *mem_ctx,
+						struct DNS_ADDR_ARRAY *addr)
+{
+	struct DNS_ADDR_ARRAY *ret;
+
+	if (!addr) {
+		return NULL;
+	}
+
+	ret = talloc_zero(mem_ctx, struct DNS_ADDR_ARRAY);
+	if (!ret) {
+		return ret;
+	}
+
+	ret->MaxCount = addr->MaxCount;
+	ret->AddrCount = addr->AddrCount;
+	ret->Family = addr->Family;
+	if (addr->AddrCount > 0) {
+		ret->AddrArray = talloc_zero_array(mem_ctx, struct DNS_ADDR, addr->AddrCount);
+		if (ret->AddrArray) {
+			memcpy(ret->AddrArray, addr->AddrArray,
+				sizeof(struct DNS_ADDR) * addr->AddrCount);
+		} else {
+			talloc_free(ret);
+			return NULL;
+		}
+	}
+	return ret;
+}
+
+
+int dns_split_name_components(TALLOC_CTX *tmp_ctx, const char *name, char ***components)
+{
+	char *str = NULL, *ptr, **list;
+	int count = 0;
+
+	if (name == NULL) {
+		return 0;
+	}
+
+	str = talloc_strdup(tmp_ctx, name);
+	if (!str) {
+		goto failed;
+	}
+
+	list = talloc_zero_array(tmp_ctx, char *, 0);
+	if (!list) {
+		goto failed;
+	}
+
+	ptr = strtok(str, ".");
+	while (ptr != NULL) {
+		count++;
+		list = talloc_realloc(tmp_ctx, list, char *, count);
+		if (!list) {
+			goto failed;
+		}
+		list[count-1] = talloc_strdup(tmp_ctx, ptr);
+		if (list[count-1] == NULL) {
+			goto failed;
+		}
+		ptr = strtok(NULL, ".");
+	}
+
+	talloc_free(str);
+
+	*components = list;
+	return count;
+
+failed:
+	TALLOC_FREE(str);
+	return -1;
+}
+
+
+char *dns_split_node_name(TALLOC_CTX *tmp_ctx, const char *node_name, const char *zone_name)
+{
+	char **nlist, **zlist;
+	char *prefix;
+	int ncount, zcount, i, match;
+
+	/*
+	 * If node_name is "@", return the zone_name
+	 * If node_name is ".", return NULL
+	 * If there is no '.' in node_name, return the node_name as is.
+	 *
+	 * If node_name does not have zone_name in it, return the node_name as is.
+	 *
+	 * If node_name has additional components as compared to zone_name
+	 *  return only the additional components as a prefix.
+	 *
+	 */
+	if (strcmp(node_name, "@") == 0) {
+		prefix = talloc_strdup(tmp_ctx, zone_name);
+	} else if (strcmp(node_name, ".") == 0) {
+		prefix = NULL;
+	} else if (strchr(node_name, '.') == NULL) {
+		prefix = talloc_strdup(tmp_ctx, node_name);
+	} else {
+		zcount = dns_split_name_components(tmp_ctx, zone_name, &zlist);
+		ncount = dns_split_name_components(tmp_ctx, node_name, &nlist);
+		if (zcount < 0 || ncount < 0) {
+			return NULL;
+		}
+
+		if (ncount < zcount) {
+			prefix = talloc_strdup(tmp_ctx, node_name);
+		} else {
+			match = 0;
+			for (i=1; i<=zcount; i++) {
+				if (strcasecmp(nlist[ncount-i], zlist[zcount-i]) != 0) {
+					break;
+				}
+				match++;
+			}
+
+			if (match == ncount) {
+				prefix = talloc_strdup(tmp_ctx, zone_name);
+			} else {
+				prefix = talloc_strdup(tmp_ctx, nlist[0]);
+				if (prefix != NULL) {
+					for (i=1; i<ncount-match; i++) {
+						prefix = talloc_asprintf_append(prefix, ".%s", nlist[i]);
+						if (prefix == NULL) {
+							break;
+						}
+					}
+				}
+			}
+		}
+
+		talloc_free(zlist);
+		talloc_free(nlist);
+	}
+
+	return prefix;
+}
+
+
+void dnsp_to_dns_copy(TALLOC_CTX *mem_ctx, struct dnsp_DnssrvRpcRecord *dnsp,
+				struct DNS_RPC_RECORD *dns)
+{
+	int i, len;
+
+	ZERO_STRUCTP(dns);
+
+	dns->wDataLength = dnsp->wDataLength;
+	dns->wType = dnsp->wType;
+	dns->dwFlags = dnsp->rank;
+	dns->dwSerial = dnsp->dwSerial;
+	dns->dwTtlSeconds = dnsp->dwTtlSeconds;
+	dns->dwTimeStamp = dnsp->dwTimeStamp;
+
+	switch (dnsp->wType) {
+
+	case DNS_TYPE_TOMBSTONE:
+		dns->data.EntombedTime = dnsp->data.EntombedTime;
+		break;
+
+	case DNS_TYPE_A:
+		dns->data.ipv4 = talloc_strdup(mem_ctx, dnsp->data.ipv4);
+		break;
+
+	case DNS_TYPE_NS:
+		len = strlen(dnsp->data.ns);
+		if (dnsp->data.ns[len-1] == '.') {
+			dns->data.name.len = len;
+			dns->data.name.str = talloc_strdup(mem_ctx, dnsp->data.ns);
+		} else {
+			dns->data.name.len = len+1;
+			dns->data.name.str = talloc_asprintf(mem_ctx, "%s.", dnsp->data.ns);
+		}
+		break;
+
+	case DNS_TYPE_CNAME:
+		len = strlen(dnsp->data.cname);
+		if (dnsp->data.cname[len-1] == '.') {
+			dns->data.name.len = len;
+			dns->data.name.str = talloc_strdup(mem_ctx, dnsp->data.cname);
+		} else {
+			dns->data.name.len = len+1;
+			dns->data.name.str = talloc_asprintf(mem_ctx, "%s.", dnsp->data.cname);
+		}
+		break;
+
+	case DNS_TYPE_SOA:
+		dns->data.soa.dwSerialNo = dnsp->data.soa.serial;
+		dns->data.soa.dwRefresh = dnsp->data.soa.refresh;
+		dns->data.soa.dwRetry = dnsp->data.soa.retry;
+		dns->data.soa.dwExpire = dnsp->data.soa.expire;
+		dns->data.soa.dwMinimumTtl = dnsp->data.soa.minimum;
+
+		len = strlen(dnsp->data.soa.mname);
+		if (dnsp->data.soa.mname[len-1] == '.') {
+			dns->data.soa.NamePrimaryServer.len = len;
+			dns->data.soa.NamePrimaryServer.str = talloc_strdup(mem_ctx, dnsp->data.soa.mname);
+		} else {
+			dns->data.soa.NamePrimaryServer.len = len+1;
+			dns->data.soa.NamePrimaryServer.str = talloc_asprintf(mem_ctx, "%s.", dnsp->data.soa.mname);
+		}
+
+		len = strlen(dnsp->data.soa.rname);
+		if (dnsp->data.soa.rname[len-1] == '.') {
+			dns->data.soa.ZoneAdministratorEmail.len = len;
+			dns->data.soa.ZoneAdministratorEmail.str = talloc_strdup(mem_ctx, dnsp->data.soa.rname);
+		} else {
+			dns->data.soa.ZoneAdministratorEmail.len = len+1;
+			dns->data.soa.ZoneAdministratorEmail.str = talloc_asprintf(mem_ctx, "%s.", dnsp->data.soa.rname);
+		}
+		break;
+
+	case DNS_TYPE_PTR:
+		dns->data.ptr.len = strlen(dnsp->data.ptr);
+		dns->data.ptr.str = talloc_strdup(mem_ctx, dnsp->data.ptr);
+		break;
+
+	case DNS_TYPE_MX:
+		dns->data.mx.wPreference = dnsp->data.mx.wPriority;
+		len = strlen(dnsp->data.mx.nameTarget);
+		if (dnsp->data.mx.nameTarget[len-1] == '.') {
+			dns->data.mx.nameExchange.len = len;
+			dns->data.mx.nameExchange.str = talloc_strdup(mem_ctx, dnsp->data.mx.nameTarget);
+		} else {
+			dns->data.mx.nameExchange.len = len+1;
+			dns->data.mx.nameExchange.str = talloc_asprintf(mem_ctx, "%s.", dnsp->data.mx.nameTarget);
+		}
+		break;
+
+	case DNS_TYPE_TXT:
+		dns->data.txt.count = dnsp->data.txt.count;
+		dns->data.txt.str = talloc_array(mem_ctx, struct DNS_RPC_NAME, dnsp->data.txt.count);
+		for (i=0; i<dnsp->data.txt.count; i++) {
+			dns->data.txt.str[i].str = talloc_strdup(mem_ctx, dnsp->data.txt.str[i]);
+			dns->data.txt.str[i].len = strlen(dnsp->data.txt.str[i]);
+		}
+		break;
+
+	case DNS_TYPE_AAAA:
+		dns->data.ipv6 = talloc_strdup(mem_ctx, dnsp->data.ipv6);
+		break;
+
+	case DNS_TYPE_SRV:
+		dns->data.srv.wPriority = dnsp->data.srv.wPriority;
+		dns->data.srv.wWeight = dnsp->data.srv.wWeight;
+		dns->data.srv.wPort = dnsp->data.srv.wPort;
+		len = strlen(dnsp->data.srv.nameTarget);
+		if (dnsp->data.srv.nameTarget[len-1] == '.') {
+			dns->data.srv.nameTarget.len = len;
+			dns->data.srv.nameTarget.str = talloc_strdup(mem_ctx, dnsp->data.srv.nameTarget);
+		} else {
+			dns->data.srv.nameTarget.len = len+1;
+			dns->data.srv.nameTarget.str = talloc_asprintf(mem_ctx, "%s.", dnsp->data.srv.nameTarget);
+		}
+		break;
+
+	default:
+		memcpy(&dns->data, &dnsp->data, sizeof(union DNS_RPC_RECORD_DATA));
+		DEBUG(0, ("dnsserver: Found Unhandled DNS record type=%d", dnsp->wType));
+	}
+
+}
+
+WERROR dns_to_dnsp_convert(TALLOC_CTX *mem_ctx, struct DNS_RPC_RECORD *dns,
+			   struct dnsp_DnssrvRpcRecord **out_dnsp, bool check_name)
+{
+	WERROR res;
+	int i, len;
+	const char *name;
+	char *talloc_res = NULL;
+	struct dnsp_DnssrvRpcRecord *dnsp = NULL;
+
+	dnsp = talloc_zero(mem_ctx, struct dnsp_DnssrvRpcRecord);
+	if (dnsp == NULL) {
+		return WERR_NOT_ENOUGH_MEMORY;
+	}
+
+	dnsp->wDataLength = dns->wDataLength;
+	dnsp->wType = dns->wType;
+	dnsp->version = 5;
+	dnsp->rank = dns->dwFlags & 0x000000FF;
+	dnsp->dwSerial = dns->dwSerial;
+	dnsp->dwTtlSeconds = dns->dwTtlSeconds;
+	dnsp->dwTimeStamp = dns->dwTimeStamp;
+
+	switch (dns->wType) {
+
+	case DNS_TYPE_TOMBSTONE:
+		dnsp->data.EntombedTime = dns->data.EntombedTime;
+		break;
+
+	case DNS_TYPE_A:
+		talloc_res = talloc_strdup(mem_ctx, dns->data.ipv4);
+		if (talloc_res == NULL) {
+			goto fail_nomemory;
+		}
+		dnsp->data.ipv4 = talloc_res;
+		break;
+
+	case DNS_TYPE_NS:
+		name = dns->data.name.str;
+		len = dns->data.name.len;
+
+		if (check_name) {
+			res = dns_name_check(mem_ctx, len, name);
+			if (!W_ERROR_IS_OK(res)) {
+				return res;
+			}
+		}
+
+		if (len > 0 && name[len-1] == '.') {
+			talloc_res = talloc_strndup(mem_ctx, name, len-1);
+			if (talloc_res == NULL) {
+				goto fail_nomemory;
+			}
+			dnsp->data.ns = talloc_res;
+		} else {
+			talloc_res = talloc_strdup(mem_ctx, name);
+			if (talloc_res == NULL) {
+				goto fail_nomemory;
+			}
+			dnsp->data.ns = talloc_res;
+		}
+
+		break;
+
+	case DNS_TYPE_CNAME:
+		name = dns->data.name.str;
+		len = dns->data.name.len;
+
+		if (check_name) {
+			res = dns_name_check(mem_ctx, len, name);
+			if (!W_ERROR_IS_OK(res)) {
+				return res;
+			}
+		}
+
+		if (len > 0 && name[len-1] == '.') {
+			talloc_res = talloc_strndup(mem_ctx, name, len-1);
+			if (talloc_res == NULL) {
+				goto fail_nomemory;
+			}
+			dnsp->data.cname = talloc_res;
+		} else {
+			talloc_res = talloc_strdup(mem_ctx, name);
+			if (talloc_res == NULL) {
+				goto fail_nomemory;
+			}
+			dnsp->data.cname = talloc_res;
+		}
+
+		break;
+
+	case DNS_TYPE_SOA:
+		dnsp->data.soa.serial = dns->data.soa.dwSerialNo;
+		dnsp->data.soa.refresh = dns->data.soa.dwRefresh;
+		dnsp->data.soa.retry = dns->data.soa.dwRetry;
+		dnsp->data.soa.expire = dns->data.soa.dwExpire;
+		dnsp->data.soa.minimum = dns->data.soa.dwMinimumTtl;
+
+		name = dns->data.soa.NamePrimaryServer.str;
+		len = dns->data.soa.NamePrimaryServer.len;
+
+		if (check_name) {
+			res = dns_name_check(mem_ctx, len, name);
+			if (!W_ERROR_IS_OK(res)) {
+				return res;
+			}
+		}
+
+		if (len > 0 && name[len-1] == '.') {
+			talloc_res = talloc_strndup(mem_ctx, name, len-1);
+			if (talloc_res == NULL) {
+				goto fail_nomemory;
+			}
+			dnsp->data.soa.mname = talloc_res;
+		} else {
+			talloc_res = talloc_strdup(mem_ctx, name);
+			if (talloc_res == NULL) {
+				goto fail_nomemory;
+			}
+			dnsp->data.soa.mname = talloc_res;
+		}
+
+		name = dns->data.soa.ZoneAdministratorEmail.str;
+		len = dns->data.soa.ZoneAdministratorEmail.len;
+
+		res = dns_name_check(mem_ctx, len, name);
+		if (!W_ERROR_IS_OK(res)) {
+			return res;
+		}
+
+		if (len > 0 && name[len-1] == '.') {
+			talloc_res = talloc_strndup(mem_ctx, name, len-1);
+			if (talloc_res == NULL) {
+				goto fail_nomemory;
+			}
+			dnsp->data.soa.rname = talloc_res;
+		} else {
+			talloc_res = talloc_strdup(mem_ctx, name);
+			if (talloc_res == NULL) {
+				goto fail_nomemory;
+			}
+			dnsp->data.soa.rname = talloc_res;
+		}
+
+		break;
+
+	case DNS_TYPE_PTR:
+		name = dns->data.ptr.str;
+		len = dns->data.ptr.len;
+
+		if (check_name) {
+			res = dns_name_check(mem_ctx, len, name);
+			if (!W_ERROR_IS_OK(res)) {
+				return res;
+			}
+		}
+
+		talloc_res = talloc_strdup(mem_ctx, name);
+		if (talloc_res == NULL) {
+			goto fail_nomemory;
+		}
+		dnsp->data.ptr = talloc_res;
+
+		break;
+
+	case DNS_TYPE_MX:
+		dnsp->data.mx.wPriority = dns->data.mx.wPreference;
+
+		name = dns->data.mx.nameExchange.str;
+		len = dns->data.mx.nameExchange.len;
+
+		if (check_name) {
+			res = dns_name_check(mem_ctx, len, name);
+			if (!W_ERROR_IS_OK(res)) {
+				return res;
+			}
+		}
+
+		if (len > 0 && name[len-1] == '.') {
+			talloc_res = talloc_strndup(mem_ctx, name, len-1);
+			if (talloc_res == NULL) {
+				goto fail_nomemory;
+			}
+			dnsp->data.mx.nameTarget = talloc_res;
+		} else {
+			talloc_res = talloc_strdup(mem_ctx, name);
+			if (talloc_res == NULL) {
+				goto fail_nomemory;
+			}
+			dnsp->data.mx.nameTarget = talloc_res;
+		}
+
+		break;
+
+	case DNS_TYPE_TXT:
+		dnsp->data.txt.count = dns->data.txt.count;
+		dnsp->data.txt.str = talloc_array(mem_ctx, const char *, dns->data.txt.count);
+		for (i=0; i<dns->data.txt.count; i++) {
+			talloc_res = talloc_strdup(mem_ctx, dns->data.txt.str[i].str);
+			if (talloc_res == NULL) {
+				goto fail_nomemory;
+			}
+			dnsp->data.txt.str[i] = talloc_res;
+		}
+		break;
+
+	case DNS_TYPE_AAAA:
+		dnsp->data.ipv6 = talloc_strdup(mem_ctx, dns->data.ipv6);
+		break;
+
+	case DNS_TYPE_SRV:
+		dnsp->data.srv.wPriority = dns->data.srv.wPriority;
+		dnsp->data.srv.wWeight = dns->data.srv.wWeight;
+		dnsp->data.srv.wPort = dns->data.srv.wPort;
+
+		name = dns->data.srv.nameTarget.str;
+		len = dns->data.srv.nameTarget.len;
+
+		if (check_name) {
+			res = dns_name_check(mem_ctx, len, name);
+			if (!W_ERROR_IS_OK(res)) {
+				return res;
+			}
+		}
+
+		if (len > 0 && name[len-1] == '.') {
+			talloc_res = talloc_strndup(mem_ctx, name, len-1);
+			if (talloc_res == NULL) {
+				goto fail_nomemory;
+			}
+			dnsp->data.srv.nameTarget = talloc_res;
+		} else {
+			talloc_res = talloc_strdup(mem_ctx, name);
+			if (talloc_res == NULL) {
+				goto fail_nomemory;
+			}
+			dnsp->data.srv.nameTarget = talloc_res;
+		}
+
+		break;
+
+	default:
+		memcpy(&dnsp->data, &dns->data, sizeof(union dnsRecordData));
+		DEBUG(0, ("dnsserver: Found Unhandled DNS record type=%d", dns->wType));
+	}
+
+	*out_dnsp = dnsp;
+	return WERR_OK;
+
+fail_nomemory:
+	return WERR_NOT_ENOUGH_MEMORY;
+}
+
+/* Intialize tree with given name as the root */
+static struct dns_tree *dns_tree_init(TALLOC_CTX *mem_ctx, const char *name, void *data)
+{
+	struct dns_tree *tree;
+
+	tree = talloc_zero(mem_ctx, struct dns_tree);
+	if (tree == NULL) {
+		return NULL;
+	}
+
+	tree->name = talloc_strdup(tree, name);
+	if (tree->name == NULL) {
+		talloc_free(tree);
+		return NULL;
+	}
+
+	tree->data = data;
+
+	return tree;
+}
+
+
+/* Add a child one level below */
+static struct dns_tree *dns_tree_add(struct dns_tree *tree, const char *name, void *data)
+{
+	struct dns_tree *node;
+
+	node = talloc_zero(tree, struct dns_tree);
+	if (node == NULL) {
+		return NULL;
+	}
+
+	node->name = talloc_strdup(tree, name);
+	if (node->name == NULL) {
+		talloc_free(node);
+		return NULL;
+	}
+	node->level = tree->level + 1;
+	node->num_children = 0;
+	node->children = NULL;
+	node->data = data;
+
+	if (tree->num_children == 0) {
+		tree->children = talloc_zero(tree, struct dns_tree *);
+	} else {
+		tree->children = talloc_realloc(tree, tree->children, struct dns_tree *,
+						tree->num_children+1);
+	}
+	if (tree->children == NULL) {
+		talloc_free(node);
+		return NULL;
+	}
+	tree->children[tree->num_children] = node;
+	tree->num_children++;
+
+	return node;
+}
+
+/* Find a node that matches the name components */
+static struct dns_tree *dns_tree_find(struct dns_tree *tree, int ncount, char **nlist, int *match_count)
+{
+	struct dns_tree *node, *next;
+	int i, j, start;
+
+	*match_count = -1;
+
+	if (strcmp(tree->name, "@") == 0) {
+		start = 0;
+	} else {
+		if (strcasecmp(tree->name, nlist[ncount-1]) != 0) {
+			return NULL;
+		}
+		start = 1;
+		*match_count = 0;
+	}
+
+	node = tree;
+	for (i=start; i<ncount; i++) {
+		if (node->num_children == 0) {
+			break;
+		}
+		next = NULL;
+		for (j=0; j<node->num_children; j++) {
+			if (strcasecmp(nlist[(ncount-1)-i], node->children[j]->name) == 0) {
+				next = node->children[j];
+				*match_count = i;
+				break;
+			}
+		}
+		if (next == NULL) {
+			break;
+		} else {
+			node = next;
+		}
+	}
+
+	return node;
+}
+
+/* Build a 2-level tree for resulting dns names */
+struct dns_tree *dns_build_tree(TALLOC_CTX *mem_ctx, const char *name, struct ldb_result *res)
+{
+	struct dns_tree *root, *base, *tree, *node;
+	const char *ptr;
+	int rootcount, ncount;
+	char **nlist;
+	int i, level, match_count;
+
+	rootcount = dns_split_name_components(mem_ctx, name, &nlist);
+	if (rootcount <= 0) {
+		return NULL;
+	}
+
+	root = dns_tree_init(mem_ctx, nlist[rootcount-1], NULL);
+	if (root == NULL) {
+		talloc_free(nlist);
+		return NULL;
+	}
+
+	tree = root;
+	for (i=rootcount-2; i>=0; i--) {
+		tree = dns_tree_add(tree, nlist[i], NULL);
+		if (tree == NULL) {
+			goto failed;
+		}
+	}
+
+	base = tree;
+
+	/* Add all names in the result in a tree */
+	for (i=0; i<res->count; i++) {
+		ptr = ldb_msg_find_attr_as_string(res->msgs[i], "name", NULL);
+		if (ptr == NULL) {
+			DBG_ERR("dnsserver: dns record has no name (%s)",
+				ldb_dn_get_linearized(res->msgs[i]->dn));
+			goto failed;
+		}
+
+		/*
+		 * This might be the sub-domain in the zone being
+		 * requested, or @ for the root of the zone
+		 */
+		if (strcasecmp(ptr, name) == 0) {
+			base->data = res->msgs[i];
+			continue;
+		}
+
+		ncount = dns_split_name_components(root, ptr, &nlist);
+		if (ncount < 0) {
+			goto failed;
+		}
+
+		/* Find matching node */
+		tree = dns_tree_find(root, ncount, nlist, &match_count);
+		if (tree == NULL) {
+			goto failed;
+		}
+
+		/* If the node is on leaf, then add record data */
+		if (match_count+1 == ncount) {
+			tree->data = res->msgs[i];
+		}
+
+		/* Add missing name components */
+		for (level=match_count+1; level<ncount; level++) {
+			if (tree->level == rootcount+1) {
+				break;
+			}
+			if (level == ncount-1) {
+				node = dns_tree_add(tree, nlist[(ncount-1)-level], res->msgs[i]);
+			} else {
+				node = dns_tree_add(tree, nlist[(ncount-1)-level], NULL);
+			}
+			if (node == NULL) {
+				goto failed;
+			}
+			tree = node;
+		}
+
+		talloc_free(nlist);
+	}
+
+	/* Mark the base record, so it can be found easily */
+	base->level = -1;
+
+	return root;
+
+failed:
+	talloc_free(nlist);
+	talloc_free(root);
+	return NULL;
+}
+
+
+static void _dns_add_name(TALLOC_CTX *mem_ctx, const char *name, char ***add_names, int *add_count)
+{
+	int i;
+	char **ptr = *add_names;
+	int count = *add_count;
+
+	for (i=0; i<count; i++) {
+		if (strcasecmp(ptr[i], name) == 0) {
+			return;
+		}
+	}
+
+	ptr = talloc_realloc(mem_ctx, ptr, char *, count+1);
+	if (ptr == NULL) {
+		return;
+	}
+
+	ptr[count] = talloc_strdup(mem_ctx, name);
+	if (ptr[count] == NULL) {
+		talloc_free(ptr);
+		return;
+	}
+
+	*add_names = ptr;
+	*add_count = count+1;
+}
+
+
+static void dns_find_additional_names(TALLOC_CTX *mem_ctx, struct dnsp_DnssrvRpcRecord *rec, char ***add_names, int *add_count)
+{
+	if (add_names == NULL) {
+		return;
+	}
+
+	switch (rec->wType) {
+
+	case DNS_TYPE_NS:
+		_dns_add_name(mem_ctx, rec->data.ns, add_names, add_count);
+		break;
+
+	case DNS_TYPE_CNAME:
+		_dns_add_name(mem_ctx, rec->data.cname, add_names, add_count);
+		break;
+
+	case DNS_TYPE_SOA:
+		_dns_add_name(mem_ctx, rec->data.soa.mname, add_names, add_count);
+		break;
+
+	case DNS_TYPE_MX:
+		_dns_add_name(mem_ctx, rec->data.mx.nameTarget, add_names, add_count);
+		break;
+
+	case DNS_TYPE_SRV:
+		_dns_add_name(mem_ctx, rec->data.srv.nameTarget, add_names, add_count);
+		break;
+
+	default:
+		break;
+	}
+}
+
+
+WERROR dns_fill_records_array(TALLOC_CTX *mem_ctx,
+				struct dnsserver_zone *z,
+				enum dns_record_type record_type,
+				unsigned int select_flag,
+				const char *branch_name,
+				struct ldb_message *msg,
+				int num_children,
+				struct DNS_RPC_RECORDS_ARRAY *recs,
+				char ***add_names,
+				int *add_count)
+{
+	struct ldb_message_element *el;
+	const char *ptr;
+	int i, j;
+	bool found;
+
+	if (recs->count == 0) {
+		recs->rec = talloc_zero(recs, struct DNS_RPC_RECORDS);
+	} else {
+		recs->rec = talloc_realloc(recs, recs->rec, struct DNS_RPC_RECORDS, recs->count+1);
+	}
+	if (recs->rec == NULL) {
+		return WERR_NOT_ENOUGH_MEMORY;
+	}
+	i = recs->count;
+	recs->rec[i].wLength = 0;
+	recs->rec[i].wRecordCount = 0;
+	recs->rec[i].dwChildCount = num_children;
+	recs->rec[i].dwFlags = 0;
+
+	/* The base records returned with empty name */
+	/* Children records returned with names */
+	if (branch_name == NULL) {
+		recs->rec[i].dnsNodeName.str = talloc_strdup(recs, "");
+		recs->rec[i].dnsNodeName.len = 0;
+	} else {
+		recs->rec[i].dnsNodeName.str = talloc_strdup(recs, branch_name);
+		recs->rec[i].dnsNodeName.len = strlen(branch_name);
+	}
+	recs->rec[i].records = talloc_zero_array(recs, struct DNS_RPC_RECORD, 0);
+	recs->count++;
+
+	/* Allow empty records */
+	if (msg == NULL) {
+		return WERR_OK;
+	}
+
+	/* Do not return RR records, if the node has children */
+	if (branch_name != NULL && num_children > 0) {
+		return WERR_OK;
+	}
+
+	ptr = ldb_msg_find_attr_as_string(msg, "name", NULL);
+	if (ptr == NULL) {
+		DBG_ERR("dnsserver: dns record has no name (%s)",
+			ldb_dn_get_linearized(msg->dn));
+		return WERR_INTERNAL_DB_ERROR;
+	}
+
+	el = ldb_msg_find_element(msg, "dnsRecord");
+	if (el == NULL || el->values == 0) {
+		return WERR_OK;
+	}
+
+	/* Add RR records */
+	for (j=0; j<el->num_values; j++) {
+		struct dnsp_DnssrvRpcRecord dnsp_rec;
+		struct DNS_RPC_RECORD *dns_rec;
+		enum ndr_err_code ndr_err;
+
+		ndr_err = ndr_pull_struct_blob(&el->values[j], mem_ctx, &dnsp_rec,
+					(ndr_pull_flags_fn_t)ndr_pull_dnsp_DnssrvRpcRecord);
+		if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+			DEBUG(0, ("dnsserver: Unable to parse dns record (%s)", ldb_dn_get_linearized(msg->dn)));
+			return WERR_INTERNAL_DB_ERROR;
+		}
+
+		/* Match the records based on search criteria */
+		if (record_type == DNS_TYPE_ALL || dnsp_rec.wType == record_type) {
+			found = false;
+
+			if (select_flag & DNS_RPC_VIEW_AUTHORITY_DATA) {
+				if (dnsp_rec.rank == DNS_RANK_ZONE) {
+					found = true;
+				} else if (dnsp_rec.rank == DNS_RANK_NS_GLUE) {
+					/*
+					 * If branch_name is NULL, we're
+					 * explicitly asked to also return
+					 * DNS_RANK_NS_GLUE records
+					 */
+					if (branch_name == NULL) {
+						found = true;
+					}
+				}
+			}
+			if (select_flag & DNS_RPC_VIEW_CACHE_DATA) {
+				if (dnsp_rec.rank == DNS_RANK_ZONE) {
+					found = true;
+				}
+			}
+			if (select_flag & DNS_RPC_VIEW_GLUE_DATA) {
+				if (dnsp_rec.rank == DNS_RANK_GLUE) {
+					found = true;
+				}
+			}
+			if (select_flag & DNS_RPC_VIEW_ROOT_HINT_DATA) {
+				if (dnsp_rec.rank == DNS_RANK_ROOT_HINT) {
+					found = true;
+				}
+			}
+
+			if (found) {
+				recs->rec[i].records = talloc_realloc(recs,
+							recs->rec[i].records,
+							struct DNS_RPC_RECORD,
+							recs->rec[i].wRecordCount+1);
+				if (recs->rec[i].records == NULL) {
+					return WERR_NOT_ENOUGH_MEMORY;
+				}
+
+				dns_rec = &recs->rec[i].records[recs->rec[i].wRecordCount];
+				dnsp_to_dns_copy(recs, &dnsp_rec, dns_rec);
+
+				/* Fix record flags */
+				if (strcmp(ptr, "@") == 0) {
+					dns_rec->dwFlags |= DNS_RPC_FLAG_ZONE_ROOT;
+
+					if (dnsp_rec.rank == DNS_RANK_ZONE) {
+						dns_rec->dwFlags |= DNS_RPC_FLAG_AUTH_ZONE_ROOT;
+					}
+				}
+
+				if (dns_rec->dwFlags == DNS_RANK_NS_GLUE) {
+					dns_rec->dwFlags |= DNS_RPC_FLAG_ZONE_ROOT;
+				}
+
+				recs->rec[i].wRecordCount++;
+
+				dns_find_additional_names(mem_ctx, &dnsp_rec, add_names, add_count);
+			}
+		}
+	}
+
+	return WERR_OK;
+}
+
+
+int dns_name_compare(struct ldb_message * const *m1, struct ldb_message * const *m2,
+		     const char *search_name)
+{
+	const char *name1, *name2;
+	const char *ptr1, *ptr2;
+
+	name1 = ldb_msg_find_attr_as_string(*m1, "name", NULL);
+	name2 = ldb_msg_find_attr_as_string(*m2, "name", NULL);
+	if (name1 == NULL || name2 == NULL) {
+		return 0;
+	}
+
+	/* Compare the last components of names.
+	 * If search_name is not NULL, compare the second last components of names */
+	ptr1 = strrchr(name1, '.');
+	if (ptr1 == NULL) {
+		ptr1 = name1;
+	} else {
+		if (search_name && strcasecmp(ptr1+1, search_name) == 0) {
+			ptr1--;
+			while (ptr1 != name1) {
+				ptr1--;
+				if (*ptr1 == '.') {
+					break;
+				}
+			}
+		}
+		if (*ptr1 == '.') {
+			ptr1 = &ptr1[1];
+		}
+	}
+
+	ptr2 = strrchr(name2, '.');
+	if (ptr2 == NULL) {
+		ptr2 = name2;
+	} else {
+		if (search_name && strcasecmp(ptr2+1, search_name) == 0) {
+			ptr2--;
+			while (ptr2 != name2) {
+				ptr2--;
+				if (*ptr2 == '.') {
+					break;
+				}
+			}
+		}
+		if (*ptr2 == '.') {
+			ptr2 = &ptr2[1];
+		}
+	}
+
+	return strcasecmp(ptr1, ptr2);
+}
diff --git a/source4/rpc_server/dnsserver/dnsdb.c b/source4/rpc_server/dnsserver/dnsdb.c
new file mode 100644
index 0000000..bde54a0
--- /dev/null
+++ b/source4/rpc_server/dnsserver/dnsdb.c
@@ -0,0 +1,1272 @@
+/*
+   Unix SMB/CIFS implementation.
+
+   DNS Server
+
+   Copyright (C) Amitay Isaacs 2011
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "includes.h"
+#include "dnsserver.h"
+#include "lib/util/dlinklist.h"
+#include "librpc/gen_ndr/ndr_dnsp.h"
+#include "librpc/gen_ndr/ndr_security.h"
+#include "librpc/gen_ndr/ndr_misc.h"
+#include "dsdb/samdb/samdb.h"
+#include "libcli/security/security.h"
+#include "dsdb/common/util.h"
+
+#undef strcasecmp
+
+/* There are only 2 fixed partitions for DNS */
+struct dnsserver_partition *dnsserver_db_enumerate_partitions(TALLOC_CTX *mem_ctx,
+							struct dnsserver_serverinfo *serverinfo,
+							struct ldb_context *samdb)
+{
+	struct dnsserver_partition *partitions, *p;
+
+	partitions = NULL;
+
+	/* Domain partition */
+	p = talloc_zero(mem_ctx, struct dnsserver_partition);
+	if (p == NULL) {
+		goto failed;
+	}
+
+	p->partition_dn = ldb_dn_new(p, samdb, serverinfo->pszDomainDirectoryPartition);
+	if (p->partition_dn == NULL) {
+		goto failed;
+	}
+
+	p->pszDpFqdn = samdb_dn_to_dns_domain(p, p->partition_dn);
+	p->dwDpFlags = DNS_DP_AUTOCREATED | DNS_DP_DOMAIN_DEFAULT | DNS_DP_ENLISTED;
+	p->is_forest = false;
+
+	DLIST_ADD_END(partitions, p);
+
+	/* Forest Partition */
+	p = talloc_zero(mem_ctx, struct dnsserver_partition);
+	if (p == NULL) {
+		goto failed;
+	}
+
+	p->partition_dn = ldb_dn_new(p, samdb, serverinfo->pszForestDirectoryPartition);
+	if (p->partition_dn == NULL) {
+		goto failed;
+	}
+
+	p->pszDpFqdn = samdb_dn_to_dns_domain(p, p->partition_dn);
+	p->dwDpFlags = DNS_DP_AUTOCREATED | DNS_DP_FOREST_DEFAULT | DNS_DP_ENLISTED;
+	p->is_forest = true;
+
+	DLIST_ADD_END(partitions, p);
+
+	return partitions;
+
+failed:
+	return NULL;
+
+}
+
+
+/* Search for all dnsZone records */
+struct dnsserver_zone *dnsserver_db_enumerate_zones(TALLOC_CTX *mem_ctx,
+						struct ldb_context *samdb,
+						struct dnsserver_partition *p)
+{
+	TALLOC_CTX *tmp_ctx;
+	const char * const attrs[] = {"name", "dNSProperty", NULL};
+	struct ldb_dn *dn;
+	struct ldb_result *res;
+	struct dnsserver_zone *zones, *z;
+	int i, j, ret;
+
+	tmp_ctx = talloc_new(mem_ctx);
+	if (tmp_ctx == NULL) {
+		return NULL;
+	}
+
+	dn = ldb_dn_copy(tmp_ctx, p->partition_dn);
+	if (dn == NULL) {
+		goto failed;
+	}
+	if (!ldb_dn_add_child_fmt(dn, "CN=MicrosoftDNS")) {
+		goto failed;
+	}
+
+	ret = ldb_search(samdb, tmp_ctx, &res, dn, LDB_SCOPE_SUBTREE,
+			  attrs, "(objectClass=dnsZone)");
+	if (ret != LDB_SUCCESS) {
+		DEBUG(0, ("dnsserver: Failed to find DNS Zones in %s\n",
+			ldb_dn_get_linearized(dn)));
+		goto failed;
+	}
+
+	zones = NULL;
+	for(i=0; i<res->count; i++) {
+		char *name;
+		struct ldb_message_element *element = NULL;
+		struct dnsp_DnsProperty *props = NULL;
+		enum ndr_err_code err;
+		z = talloc_zero(mem_ctx, struct dnsserver_zone);
+		if (z == NULL) {
+			goto failed;
+		}
+
+		z->partition = p;
+		name = talloc_strdup(z,
+				ldb_msg_find_attr_as_string(res->msgs[i],
+							    "name", NULL));
+		if (strcmp(name, "..TrustAnchors") == 0) {
+			talloc_free(z);
+			continue;
+		}
+		if (strcmp(name, "RootDNSServers") == 0) {
+			talloc_free(name);
+			z->name = talloc_strdup(z, ".");
+		} else {
+			z->name = name;
+		}
+		z->zone_dn = talloc_steal(z, res->msgs[i]->dn);
+
+		DLIST_ADD_END(zones, z);
+		DEBUG(2, ("dnsserver: Found DNS zone %s\n", z->name));
+
+		element = ldb_msg_find_element(res->msgs[i], "dNSProperty");
+		if(element != NULL){
+			props = talloc_zero_array(tmp_ctx,
+						  struct dnsp_DnsProperty,
+						  element->num_values);
+			for (j = 0; j < element->num_values; j++ ) {
+				err = ndr_pull_struct_blob(
+					&(element->values[j]),
+					mem_ctx,
+					&props[j],
+					(ndr_pull_flags_fn_t)
+						ndr_pull_dnsp_DnsProperty);
+				if (!NDR_ERR_CODE_IS_SUCCESS(err)){
+					/*
+					 * Per Microsoft we must
+					 * ignore invalid data here
+					 * and continue as a Windows
+					 * server can put in a
+					 * structure with an invalid
+					 * length.
+					 *
+					 * We can safely fill in an
+					 * extra empty property here
+					 * because
+					 * dns_zoneinfo_load_zone_property()
+					 * just ignores
+					 * DSPROPERTY_ZONE_EMPTY
+					 */
+					ZERO_STRUCT(props[j]);
+					props[j].id = DSPROPERTY_ZONE_EMPTY;
+					continue;
+				}
+			}
+			z->tmp_props = props;
+			z->num_props = element->num_values;
+		}
+	}
+	return zones;
+
+failed:
+	talloc_free(tmp_ctx);
+	return NULL;
+}
+
+
+/* Find DNS partition information */
+struct dnsserver_partition_info *dnsserver_db_partition_info(TALLOC_CTX *mem_ctx,
+							struct ldb_context *samdb,
+							struct dnsserver_partition *p)
+{
+	const char * const attrs[] = { "instanceType", "msDs-masteredBy", NULL };
+	const char * const attrs_none[] = { NULL };
+	struct ldb_result *res;
+	struct ldb_message_element *el;
+	struct ldb_dn *dn;
+	struct dnsserver_partition_info *partinfo;
+	int i, ret, instance_type;
+	TALLOC_CTX *tmp_ctx;
+
+	tmp_ctx = talloc_new(mem_ctx);
+	if (tmp_ctx == NULL) {
+		return NULL;
+	}
+
+	partinfo = talloc_zero(mem_ctx, struct dnsserver_partition_info);
+	if (partinfo == NULL) {
+		talloc_free(tmp_ctx);
+		return NULL;
+	}
+
+	/* Search for the active replica and state */
+	ret = ldb_search(samdb, tmp_ctx, &res, p->partition_dn, LDB_SCOPE_BASE,
+			attrs, NULL);
+	if (ret != LDB_SUCCESS || res->count != 1) {
+		goto failed;
+	}
+
+	/* Set the state of the partition */
+	instance_type = ldb_msg_find_attr_as_int(res->msgs[0], "instanceType", -1);
+	if (instance_type == -1) {
+		partinfo->dwState = DNS_DP_STATE_UNKNOWN;
+	} else if (instance_type & INSTANCE_TYPE_NC_COMING) {
+		partinfo->dwState = DNS_DP_STATE_REPL_INCOMING;
+	} else if (instance_type & INSTANCE_TYPE_NC_GOING) {
+		partinfo->dwState = DNS_DP_STATE_REPL_OUTGOING;
+	} else {
+		partinfo->dwState = DNS_DP_OKAY;
+	}
+
+	el = ldb_msg_find_element(res->msgs[0], "msDs-masteredBy");
+	if (el == NULL) {
+		partinfo->dwReplicaCount = 0;
+		partinfo->ReplicaArray = NULL;
+	} else {
+		partinfo->dwReplicaCount = el->num_values;
+		partinfo->ReplicaArray = talloc_zero_array(partinfo,
+							   struct DNS_RPC_DP_REPLICA *,
+							   el->num_values);
+		if (partinfo->ReplicaArray == NULL) {
+			goto failed;
+		}
+		for (i=0; i<el->num_values; i++) {
+			partinfo->ReplicaArray[i] = talloc_zero(partinfo,
+							struct DNS_RPC_DP_REPLICA);
+			if (partinfo->ReplicaArray[i] == NULL) {
+				goto failed;
+			}
+			partinfo->ReplicaArray[i]->pszReplicaDn = talloc_strdup(
+									partinfo,
+									(const char *)el->values[i].data);
+			if (partinfo->ReplicaArray[i]->pszReplicaDn == NULL) {
+				goto failed;
+			}
+		}
+	}
+	talloc_free(res);
+
+	/* Search for cross-reference object */
+	dn = ldb_dn_copy(tmp_ctx, ldb_get_config_basedn(samdb));
+	if (dn == NULL) {
+		goto failed;
+	}
+
+	ret = ldb_search(samdb, tmp_ctx, &res, dn, LDB_SCOPE_DEFAULT, attrs_none,
+			"(nCName=%s)", ldb_dn_get_linearized(p->partition_dn));
+	if (ret != LDB_SUCCESS || res->count != 1) {
+		goto failed;
+	}
+	partinfo->pszCrDn = talloc_strdup(partinfo, ldb_dn_get_linearized(res->msgs[0]->dn));
+	if (partinfo->pszCrDn == NULL) {
+		goto failed;
+	}
+	talloc_free(res);
+
+	talloc_free(tmp_ctx);
+	return partinfo;
+
+failed:
+	talloc_free(tmp_ctx);
+	talloc_free(partinfo);
+	return NULL;
+}
+
+
+/* Increment serial number and update timestamp */
+static unsigned int dnsserver_update_soa(TALLOC_CTX *mem_ctx,
+				struct ldb_context *samdb,
+				struct dnsserver_zone *z,
+				WERROR *werr)
+{
+	const char * const attrs[] = { "dnsRecord", NULL };
+	struct ldb_result *res;
+	struct dnsp_DnssrvRpcRecord rec;
+	struct ldb_message_element *el;
+	enum ndr_err_code ndr_err;
+	int ret, i, serial = -1;
+
+	*werr = WERR_INTERNAL_DB_ERROR;
+
+	ret = ldb_search(samdb, mem_ctx, &res, z->zone_dn, LDB_SCOPE_ONELEVEL, attrs,
+			"(&(objectClass=dnsNode)(name=@))");
+	if (ret != LDB_SUCCESS || res->count == 0) {
+		return -1;
+	}
+
+	el = ldb_msg_find_element(res->msgs[0], "dnsRecord");
+	if (el == NULL) {
+		return -1;
+	}
+
+	for (i=0; i<el->num_values; i++) {
+		ndr_err = ndr_pull_struct_blob(&el->values[i], mem_ctx, &rec,
+					(ndr_pull_flags_fn_t)ndr_pull_dnsp_DnssrvRpcRecord);
+		if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+			continue;
+		}
+
+		if (rec.wType == DNS_TYPE_SOA) {
+			serial = rec.data.soa.serial + 1;
+			rec.dwSerial = serial;
+			rec.dwTimeStamp = 0;
+			rec.data.soa.serial = serial;
+
+			ndr_err = ndr_push_struct_blob(&el->values[i], mem_ctx, &rec,
+					(ndr_push_flags_fn_t)ndr_push_dnsp_DnssrvRpcRecord);
+			if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+				*werr = WERR_NOT_ENOUGH_MEMORY;
+				return -1;
+			}
+			break;
+		}
+	}
+
+	if (serial != -1) {
+		el->flags = LDB_FLAG_MOD_REPLACE;
+		ret = ldb_modify(samdb, res->msgs[0]);
+		if (ret != LDB_SUCCESS) {
+			if (ret == LDB_ERR_INSUFFICIENT_ACCESS_RIGHTS) {
+				*werr = WERR_ACCESS_DENIED;
+			}
+			return -1;
+		}
+	}
+
+	*werr = WERR_OK;
+
+	return serial;
+}
+
+
+/* Add DNS record to the database */
+static WERROR dnsserver_db_do_add_rec(TALLOC_CTX *mem_ctx,
+				struct ldb_context *samdb,
+				struct ldb_dn *dn,
+				int num_rec,
+				struct dnsp_DnssrvRpcRecord *rec)
+{
+	struct ldb_message *msg;
+	struct ldb_val v;
+	int ret;
+	enum ndr_err_code ndr_err;
+	int i;
+
+	msg = ldb_msg_new(mem_ctx);
+	W_ERROR_HAVE_NO_MEMORY(msg);
+
+	msg->dn = dn;
+	ret = ldb_msg_add_string(msg, "objectClass", "dnsNode");
+	if (ret != LDB_SUCCESS) {
+		return WERR_NOT_ENOUGH_MEMORY;
+	}
+
+	if (num_rec > 0 && rec) {
+		for (i=0; i<num_rec; i++) {
+			ndr_err = ndr_push_struct_blob(&v, mem_ctx, &rec[i],
+					(ndr_push_flags_fn_t)ndr_push_dnsp_DnssrvRpcRecord);
+			if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+				return WERR_GEN_FAILURE;
+			}
+
+			ret = ldb_msg_add_value(msg, "dnsRecord", &v, NULL);
+			if (ret != LDB_SUCCESS) {
+				return WERR_NOT_ENOUGH_MEMORY;
+			}
+		}
+	}
+
+	ret = ldb_add(samdb, msg);
+	if (ret != LDB_SUCCESS) {
+		return WERR_INTERNAL_DB_ERROR;
+	}
+
+	return WERR_OK;
+}
+
+
+/* Add dnsNode record to the database with DNS record */
+WERROR dnsserver_db_add_empty_node(TALLOC_CTX *mem_ctx,
+					struct ldb_context *samdb,
+					struct dnsserver_zone *z,
+					const char *name)
+{
+	const char * const attrs[] = { "name", NULL };
+	struct ldb_result *res;
+	struct ldb_dn *dn;
+	char *encoded_name = ldb_binary_encode_string(mem_ctx, name);
+	struct ldb_val name_val = data_blob_string_const(name);
+	int ret;
+
+	ret = ldb_search(samdb, mem_ctx, &res, z->zone_dn, LDB_SCOPE_BASE, attrs,
+			"(&(objectClass=dnsNode)(name=%s))",
+			 encoded_name);
+	if (ret != LDB_SUCCESS) {
+		return WERR_INTERNAL_DB_ERROR;
+	}
+
+	if (res->count > 0) {
+		talloc_free(res);
+		return WERR_DNS_ERROR_RECORD_ALREADY_EXISTS;
+	}
+
+	dn = ldb_dn_copy(mem_ctx, z->zone_dn);
+	W_ERROR_HAVE_NO_MEMORY(dn);
+
+	if (!ldb_dn_add_child_val(dn, "DC", name_val)) {
+		return WERR_NOT_ENOUGH_MEMORY;
+	}
+
+	return dnsserver_db_do_add_rec(mem_ctx, samdb, dn, 0, NULL);
+}
+
+static void set_record_rank(struct dnsserver_zone *z,
+			    const char *name,
+			    struct dnsp_DnssrvRpcRecord *rec)
+{
+	if (z->zoneinfo->dwZoneType == DNS_ZONE_TYPE_PRIMARY) {
+		if (strcmp(name, "@") != 0 && rec->wType == DNS_TYPE_NS) {
+			rec->rank = DNS_RANK_NS_GLUE;
+		} else {
+			rec->rank = DNS_RANK_ZONE;
+		}
+	} else if (strcmp(z->name, ".") == 0) {
+		rec->rank = DNS_RANK_ROOT_HINT;
+	}
+}
+
+
+/* Add a DNS record */
+WERROR dnsserver_db_add_record(TALLOC_CTX *mem_ctx,
+					struct ldb_context *samdb,
+					struct dnsserver_zone *z,
+					const char *name,
+					struct DNS_RPC_RECORD *add_record)
+{
+	const char * const attrs[] = { "dnsRecord", "dNSTombstoned", NULL };
+	struct ldb_result *res;
+	struct dnsp_DnssrvRpcRecord *rec = NULL;
+	struct ldb_message_element *el;
+	struct ldb_dn *dn;
+	enum ndr_err_code ndr_err;
+	int ret, i;
+	int serial;
+	WERROR werr;
+	bool was_tombstoned = false;
+	char *encoded_name = ldb_binary_encode_string(mem_ctx, name);
+
+	werr = dns_to_dnsp_convert(mem_ctx, add_record, &rec, true);
+	if (!W_ERROR_IS_OK(werr)) {
+		return werr;
+	}
+
+	/* Set the correct rank for the record. */
+	set_record_rank(z, name, rec);
+
+	serial = dnsserver_update_soa(mem_ctx, samdb, z, &werr);
+	if (serial < 0) {
+		return werr;
+	}
+
+	rec->dwSerial = serial;
+	rec->dwTimeStamp = 0;
+
+	ret = ldb_search(samdb, mem_ctx, &res, z->zone_dn, LDB_SCOPE_ONELEVEL, attrs,
+			"(&(objectClass=dnsNode)(name=%s))",
+			 encoded_name);
+	if (ret != LDB_SUCCESS) {
+		return WERR_INTERNAL_DB_ERROR;
+	}
+
+	if (res->count == 0) {
+		dn = dnsserver_name_to_dn(mem_ctx, z, name);
+		W_ERROR_HAVE_NO_MEMORY(dn);
+
+		return dnsserver_db_do_add_rec(mem_ctx, samdb, dn, 1, rec);
+	}
+
+	el = ldb_msg_find_element(res->msgs[0], "dnsRecord");
+	if (el == NULL) {
+		ret = ldb_msg_add_empty(res->msgs[0], "dnsRecord", 0, &el);
+		if (ret != LDB_SUCCESS) {
+			return WERR_NOT_ENOUGH_MEMORY;
+		}
+	}
+
+	was_tombstoned = ldb_msg_find_attr_as_bool(res->msgs[0],
+						   "dNSTombstoned", false);
+	if (was_tombstoned) {
+		el->num_values = 0;
+	}
+
+	for (i=0; i<el->num_values; i++) {
+		struct dnsp_DnssrvRpcRecord rec2;
+
+		ndr_err = ndr_pull_struct_blob(&el->values[i], mem_ctx, &rec2,
+						(ndr_pull_flags_fn_t)ndr_pull_dnsp_DnssrvRpcRecord);
+		if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+			return WERR_GEN_FAILURE;
+		}
+
+		if (dns_record_match(rec, &rec2)) {
+			break;
+		}
+	}
+	if (i < el->num_values) {
+		return WERR_DNS_ERROR_RECORD_ALREADY_EXISTS;
+	}
+	if (i == el->num_values) {
+		/* adding a new value */
+		el->values = talloc_realloc(el, el->values, struct ldb_val, el->num_values+1);
+		W_ERROR_HAVE_NO_MEMORY(el->values);
+		el->num_values++;
+	}
+
+	ndr_err = ndr_push_struct_blob(&el->values[i], mem_ctx, rec,
+					(ndr_push_flags_fn_t)ndr_push_dnsp_DnssrvRpcRecord);
+	if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+		return WERR_GEN_FAILURE;
+	}
+
+	el->flags = LDB_FLAG_MOD_REPLACE;
+
+	el = ldb_msg_find_element(res->msgs[0], "dNSTombstoned");
+	if (el != NULL) {
+		el->flags = LDB_FLAG_MOD_DELETE;
+	}
+
+	ret = ldb_modify(samdb, res->msgs[0]);
+	if (ret != LDB_SUCCESS) {
+		return WERR_INTERNAL_DB_ERROR;
+	}
+
+	return WERR_OK;
+}
+
+
+/* Update a DNS record */
+WERROR dnsserver_db_update_record(TALLOC_CTX *mem_ctx,
+					struct ldb_context *samdb,
+					struct dnsserver_zone *z,
+					const char *name,
+					struct DNS_RPC_RECORD *add_record,
+					struct DNS_RPC_RECORD *del_record)
+{
+	const char * const attrs[] = { "dnsRecord", NULL };
+	struct ldb_result *res;
+	struct dnsp_DnssrvRpcRecord rec2;
+	struct dnsp_DnssrvRpcRecord *arec = NULL, *drec = NULL;
+	struct ldb_message_element *el;
+	enum ndr_err_code ndr_err;
+	int ret, i;
+	int serial;
+	WERROR werr;
+	bool updating_ttl = false;
+	char *encoded_name = ldb_binary_encode_string(mem_ctx, name);
+
+	werr = dns_to_dnsp_convert(mem_ctx, add_record, &arec, true);
+	if (!W_ERROR_IS_OK(werr)) {
+		return werr;
+	}
+
+	werr = dns_to_dnsp_convert(mem_ctx, del_record, &drec, true);
+	if (!W_ERROR_IS_OK(werr)) {
+		return werr;
+	}
+
+	ret = ldb_search(samdb, mem_ctx, &res, z->zone_dn, LDB_SCOPE_ONELEVEL, attrs,
+			"(&(objectClass=dnsNode)(name=%s)(!(dNSTombstoned=TRUE)))",
+			 encoded_name);
+	if (ret != LDB_SUCCESS) {
+		return WERR_INTERNAL_DB_ERROR;
+	}
+
+	if (res->count == 0) {
+		return WERR_DNS_ERROR_RECORD_DOES_NOT_EXIST;
+	}
+
+	el = ldb_msg_find_element(res->msgs[0], "dnsRecord");
+	if (el == NULL || el->num_values == 0) {
+		return WERR_DNS_ERROR_RECORD_DOES_NOT_EXIST;
+	}
+
+	for (i=0; i<el->num_values; i++) {
+		ndr_err = ndr_pull_struct_blob(&el->values[i], mem_ctx, &rec2,
+						(ndr_pull_flags_fn_t)ndr_pull_dnsp_DnssrvRpcRecord);
+		if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+			return WERR_GEN_FAILURE;
+		}
+
+		if (dns_record_match(arec, &rec2)) {
+			break;
+		}
+	}
+	if (i < el->num_values) {
+		/*
+		 * The record already exists, which is an error UNLESS we are
+		 * doing an in-place update.
+		 *
+		 * Therefore we need to see if drec also matches, in which
+		 * case it's OK, though we can only update dwTtlSeconds and
+		 * reset the timestamp to zero.
+		 */
+		updating_ttl = dns_record_match(drec, &rec2);
+		if (! updating_ttl) {
+			return WERR_DNS_ERROR_RECORD_ALREADY_EXISTS;
+		}
+		/* In this case the next loop is redundant */
+	}
+
+	for (i=0; i<el->num_values; i++) {
+		ndr_err = ndr_pull_struct_blob(&el->values[i], mem_ctx, &rec2,
+						(ndr_pull_flags_fn_t)ndr_pull_dnsp_DnssrvRpcRecord);
+		if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+			return WERR_GEN_FAILURE;
+		}
+
+		if (dns_record_match(drec, &rec2)) {
+			/*
+			 * we are replacing this one with arec, which is done
+			 * by pushing arec into el->values[i] below, after the
+			 * various manipulations.
+			 */
+			break;
+		}
+	}
+	if (i == el->num_values) {
+		return WERR_DNS_ERROR_RECORD_DOES_NOT_EXIST;
+	}
+
+	/*
+	 * If we're updating a SOA record, use the specified serial.
+	 *
+	 * Otherwise, if we are updating ttl in place (i.e., not changing
+	 * .wType and .data on a record), we should increment the existing
+	 * serial, and save to the SOA.
+	 *
+	 * Outside of those two cases, we look for the zone's SOA record and
+	 * use its serial.
+	 */
+	if (arec->wType != DNS_TYPE_SOA) {
+		if (updating_ttl) {
+			/*
+			 * In this case, we keep some of the old values.
+			 */
+			arec->dwSerial = rec2.dwSerial;
+			arec->dwReserved = rec2.dwReserved;
+			/*
+			 * TODO: if the old TTL and the new TTL are
+			 * different, the serial number is incremented.
+			 */
+		} else {
+			arec->dwReserved = 0;
+			serial = dnsserver_update_soa(mem_ctx, samdb, z, &werr);
+			if (serial < 0) {
+				return werr;
+			}
+			arec->dwSerial = serial;
+		}
+	}
+
+	/* Set the correct rank for the record. */
+	set_record_rank(z, name, arec);
+	/*
+	 * Successful RPC updates *always* zero timestamp and flags and set
+	 * version.
+	 */
+	arec->dwTimeStamp = 0;
+	arec->version = 5;
+	arec->flags = 0;
+
+	ndr_err = ndr_push_struct_blob(&el->values[i], mem_ctx, arec,
+					(ndr_push_flags_fn_t)ndr_push_dnsp_DnssrvRpcRecord);
+	if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+		return WERR_GEN_FAILURE;
+	}
+
+	el->flags = LDB_FLAG_MOD_REPLACE;
+	ret = ldb_modify(samdb, res->msgs[0]);
+	if (ret != LDB_SUCCESS) {
+		return WERR_INTERNAL_DB_ERROR;
+	}
+
+	return WERR_OK;
+}
+
+
+/* Delete a DNS record */
+WERROR dnsserver_db_delete_record(TALLOC_CTX *mem_ctx,
+					struct ldb_context *samdb,
+					struct dnsserver_zone *z,
+					const char *name,
+					struct DNS_RPC_RECORD *del_record)
+{
+	const char * const attrs[] = { "dnsRecord", NULL };
+	struct ldb_result *res;
+	struct dnsp_DnssrvRpcRecord *rec = NULL;
+	struct ldb_message_element *el;
+	enum ndr_err_code ndr_err;
+	int ret, i;
+	int serial;
+	WERROR werr;
+
+	serial = dnsserver_update_soa(mem_ctx, samdb, z, &werr);
+	if (serial < 0) {
+		return werr;
+	}
+
+	werr = dns_to_dnsp_convert(mem_ctx, del_record, &rec, false);
+	if (!W_ERROR_IS_OK(werr)) {
+		return werr;
+	}
+
+	ret = ldb_search(samdb, mem_ctx, &res, z->zone_dn, LDB_SCOPE_ONELEVEL, attrs,
+			"(&(objectClass=dnsNode)(name=%s))",
+			 ldb_binary_encode_string(mem_ctx, name));
+	if (ret != LDB_SUCCESS) {
+		return WERR_INTERNAL_DB_ERROR;
+	}
+
+	if (res->count == 0) {
+		return WERR_DNS_ERROR_RECORD_DOES_NOT_EXIST;
+	}
+	if (res->count > 1) {
+		return WERR_DNS_ERROR_RCODE_SERVER_FAILURE;
+	}
+
+	el = ldb_msg_find_element(res->msgs[0], "dnsRecord");
+	if (el == NULL || el->num_values == 0) {
+		return WERR_DNS_ERROR_RECORD_DOES_NOT_EXIST;
+	}
+
+	for (i=0; i<el->num_values; i++) {
+		struct dnsp_DnssrvRpcRecord rec2;
+
+		ndr_err = ndr_pull_struct_blob(&el->values[i], mem_ctx, &rec2,
+						(ndr_pull_flags_fn_t)ndr_pull_dnsp_DnssrvRpcRecord);
+		if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+			return WERR_GEN_FAILURE;
+		}
+
+		if (dns_record_match(rec, &rec2)) {
+			break;
+		}
+	}
+	if (i == el->num_values) {
+		return WERR_DNS_ERROR_RECORD_DOES_NOT_EXIST;
+	}
+	if (i < el->num_values-1) {
+		memmove(&el->values[i], &el->values[i+1], sizeof(el->values[0])*((el->num_values-1)-i));
+	}
+	el->num_values--;
+
+	if (el->num_values == 0) {
+		ret = ldb_delete(samdb, res->msgs[0]->dn);
+	} else {
+		el->flags = LDB_FLAG_MOD_REPLACE;
+		ret = ldb_modify(samdb, res->msgs[0]);
+	}
+	if (ret != LDB_SUCCESS) {
+		return WERR_INTERNAL_DB_ERROR;
+	}
+
+	return WERR_OK;
+}
+
+
+static bool dnsserver_db_msg_add_dnsproperty(TALLOC_CTX *mem_ctx,
+					     struct ldb_message *msg,
+					     struct dnsp_DnsProperty *prop)
+{
+	DATA_BLOB *prop_blob;
+	enum ndr_err_code ndr_err;
+	int ret;
+
+	prop_blob = talloc_zero(mem_ctx, DATA_BLOB);
+	if (prop_blob == NULL) return false;
+
+	ndr_err = ndr_push_struct_blob(prop_blob, mem_ctx, prop,
+			(ndr_push_flags_fn_t)ndr_push_dnsp_DnsProperty);
+	if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+		return false;
+	}
+	ret = ldb_msg_add_steal_value(msg, "dNSProperty", prop_blob);
+	if (ret != LDB_SUCCESS) {
+		return false;
+	}
+	return true;
+}
+
+WERROR dnsserver_db_do_reset_dword(struct ldb_context *samdb,
+				   struct dnsserver_zone *z,
+				   struct DNS_RPC_NAME_AND_PARAM *n_p)
+{
+	struct ldb_message_element *element = NULL;
+	struct dnsp_DnsProperty *prop = NULL;
+	enum ndr_err_code err;
+	TALLOC_CTX *tmp_ctx = NULL;
+	const char * const attrs[] = {"dNSProperty", NULL};
+	struct ldb_result *res = NULL;
+	int i, ret, prop_id;
+
+	if (strcasecmp(n_p->pszNodeName, "Aging") == 0) {
+		z->zoneinfo->fAging = n_p->dwParam;
+		prop_id = DSPROPERTY_ZONE_AGING_STATE;
+	} else if (strcasecmp(n_p->pszNodeName, "RefreshInterval") == 0) {
+		z->zoneinfo->dwRefreshInterval = n_p->dwParam;
+		prop_id = DSPROPERTY_ZONE_REFRESH_INTERVAL;
+	} else if (strcasecmp(n_p->pszNodeName, "NoRefreshInterval") == 0) {
+		z->zoneinfo->dwNoRefreshInterval = n_p->dwParam;
+		prop_id = DSPROPERTY_ZONE_NOREFRESH_INTERVAL;
+	} else if (strcasecmp(n_p->pszNodeName, "AllowUpdate") == 0) {
+		z->zoneinfo->fAllowUpdate = n_p->dwParam;
+		prop_id = DSPROPERTY_ZONE_ALLOW_UPDATE;
+	} else {
+		return WERR_UNKNOWN_PROPERTY;
+	}
+
+	tmp_ctx = talloc_new(NULL);
+	if (tmp_ctx == NULL) {
+		return WERR_NOT_ENOUGH_MEMORY;
+	}
+
+	ret = ldb_search(samdb, tmp_ctx, &res, z->zone_dn, LDB_SCOPE_BASE,
+			 attrs, "(objectClass=dnsZone)");
+	if (ret != LDB_SUCCESS) {
+		DBG_ERR("dnsserver: no zone: %s\n",
+			ldb_dn_get_linearized(z->zone_dn));
+		TALLOC_FREE(tmp_ctx);
+		return WERR_INTERNAL_DB_ERROR;
+	}
+
+	if (res->count != 1) {
+		DBG_ERR("dnsserver: duplicate zone: %s\n",
+			ldb_dn_get_linearized(z->zone_dn));
+		TALLOC_FREE(tmp_ctx);
+		return WERR_GEN_FAILURE;
+	}
+
+	element = ldb_msg_find_element(res->msgs[0], "dNSProperty");
+	if (element == NULL) {
+		DBG_ERR("dnsserver: zone %s has no properties.\n",
+			ldb_dn_get_linearized(z->zone_dn));
+		TALLOC_FREE(tmp_ctx);
+		return WERR_INTERNAL_DB_ERROR;
+	}
+
+	for (i = 0; i < element->num_values; i++) {
+		prop = talloc_zero(element, struct dnsp_DnsProperty);
+		if (prop == NULL) {
+			TALLOC_FREE(tmp_ctx);
+			return WERR_NOT_ENOUGH_MEMORY;
+		}
+		err = ndr_pull_struct_blob(
+			&(element->values[i]),
+			tmp_ctx,
+			prop,
+			(ndr_pull_flags_fn_t)ndr_pull_dnsp_DnsProperty);
+		if (!NDR_ERR_CODE_IS_SUCCESS(err)){
+			/*
+			 * If we can't pull it then try again parsing
+			 * it again.  A Windows server in the domain
+			 * will permit the addition of an invalidly
+			 * formed property with a 0 length and cause a
+			 * failure here
+			 */
+			struct dnsp_DnsProperty_short
+				*short_property
+				= talloc_zero(element,
+					      struct dnsp_DnsProperty_short);
+			if (short_property == NULL) {
+				TALLOC_FREE(tmp_ctx);
+				return WERR_NOT_ENOUGH_MEMORY;
+			}
+			err = ndr_pull_struct_blob_all(
+				&(element->values[i]),
+				tmp_ctx,
+				short_property,
+				(ndr_pull_flags_fn_t)ndr_pull_dnsp_DnsProperty_short);
+			if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
+				/*
+				 * Unknown invalid data should be
+				 * ignored and logged to match Windows
+				 * behaviour
+				 */
+				DBG_NOTICE("dnsserver: couldn't PULL "
+					   "dnsProperty value#%d in "
+					   "zone %s while trying to "
+					   "reset id %d\n",
+					   i,
+					   ldb_dn_get_linearized(z->zone_dn),
+					   prop_id);
+				continue;
+			}
+
+			/*
+			 * Initialise the parts of the property not
+			 * overwritten by value() in the IDL for
+			 * re-push
+			 */
+			*prop = (struct dnsp_DnsProperty){
+				.namelength = short_property->namelength,
+				.id = short_property->id,
+				.name = short_property->name
+				/* .data will be filled in below */
+			};
+		}
+
+		if (prop->id == prop_id) {
+			switch (prop_id) {
+			case DSPROPERTY_ZONE_AGING_STATE:
+				prop->data.aging_enabled = n_p->dwParam;
+				break;
+			case DSPROPERTY_ZONE_NOREFRESH_INTERVAL:
+				prop->data.norefresh_hours = n_p->dwParam;
+				break;
+			case DSPROPERTY_ZONE_REFRESH_INTERVAL:
+				prop->data.refresh_hours = n_p->dwParam;
+				break;
+			case DSPROPERTY_ZONE_ALLOW_UPDATE:
+				prop->data.allow_update_flag = n_p->dwParam;
+				break;
+			}
+
+			err = ndr_push_struct_blob(
+				&(element->values[i]),
+				tmp_ctx,
+				prop,
+				(ndr_push_flags_fn_t)ndr_push_dnsp_DnsProperty);
+			if (!NDR_ERR_CODE_IS_SUCCESS(err)){
+				DBG_ERR("dnsserver: couldn't PUSH dns prop id "
+					"%d in zone %s\n",
+					prop->id,
+					ldb_dn_get_linearized(z->zone_dn));
+				TALLOC_FREE(tmp_ctx);
+				return WERR_INTERNAL_DB_ERROR;
+			}
+		}
+	}
+
+	element->flags = LDB_FLAG_MOD_REPLACE;
+	ret = ldb_modify(samdb, res->msgs[0]);
+	if (ret != LDB_SUCCESS) {
+		TALLOC_FREE(tmp_ctx);
+		DBG_ERR("dnsserver: Failed to modify zone %s prop %s: %s\n",
+			z->name,
+			n_p->pszNodeName,
+			ldb_errstring(samdb));
+		return WERR_INTERNAL_DB_ERROR;
+	}
+	TALLOC_FREE(tmp_ctx);
+
+	return WERR_OK;
+}
+
+/* Create dnsZone record to database and set security descriptor */
+static WERROR dnsserver_db_do_create_zone(TALLOC_CTX *tmp_ctx,
+					  struct ldb_context *samdb,
+					  struct ldb_dn *zone_dn,
+					  struct dnsserver_zone *z)
+{
+	const char * const attrs[] = { "objectSID", NULL };
+	struct ldb_message *msg;
+	struct ldb_result *res;
+	struct ldb_message_element *el;
+	const char sddl_template[] = "D:AI(A;;RPWPCRCCDCLCLORCWOWDSDDTSW;;;DA)(A;;CC;;;AU)(A;;RPLCLORC;;;WD)(A;;RPWPCRCCDCLCLORCWOWDSDDTSW;;;SY)(A;CI;RPWPCRCCDCLCRCWOWDSDDTSW;;;ED)(A;CIID;RPWPCRCCDCLCRCWOWDSDDTSW;;;%s)(A;CIID;RPWPCRCCDCLCRCWOWDSDDTSW;;;ED)(OA;CIID;RPWPCR;91e647de-d96f-4b70-9557-d63ff4f3ccd8;;PS)(A;CIID;RPWPCRCCDCLCLORCWOWDSDDTSW;;;EA)(A;CIID;LC;;;RU)(A;CIID;RPWPCRCCLCLORCWOWDSDSW;;;BA)S:AI";
+	char *sddl;
+	struct dom_sid dnsadmins_sid;
+	const struct dom_sid *domain_sid;
+	struct security_descriptor *secdesc;
+	struct dnsp_DnsProperty *prop;
+	DATA_BLOB *sd_encoded;
+	enum ndr_err_code ndr_err;
+	int ret;
+
+	/* Get DnsAdmins SID */
+	ret = ldb_search(samdb, tmp_ctx, &res, ldb_get_default_basedn(samdb),
+			 LDB_SCOPE_DEFAULT, attrs, "(sAMAccountName=DnsAdmins)");
+	if (ret != LDB_SUCCESS || res->count != 1) {
+		return WERR_INTERNAL_DB_ERROR;
+	}
+
+	el = ldb_msg_find_element(res->msgs[0], "objectSID");
+	if (el == NULL || el->num_values != 1) {
+		return WERR_INTERNAL_DB_ERROR;
+	}
+
+	ndr_err = ndr_pull_struct_blob(&el->values[0], tmp_ctx, &dnsadmins_sid,
+				(ndr_pull_flags_fn_t)ndr_pull_dom_sid);
+	if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+		return WERR_INTERNAL_DB_ERROR;
+	}
+
+	/* create security descriptor with DnsAdmins GUID in sddl template */
+	sddl = talloc_asprintf(tmp_ctx, sddl_template,
+			       dom_sid_string(tmp_ctx, &dnsadmins_sid));
+	if (sddl == NULL) {
+		return WERR_NOT_ENOUGH_MEMORY;
+	}
+	talloc_free(res);
+
+	domain_sid = samdb_domain_sid(samdb);
+	if (domain_sid == NULL) {
+		return WERR_INTERNAL_DB_ERROR;
+	}
+
+	secdesc = sddl_decode(tmp_ctx, sddl, domain_sid);
+	if (secdesc == NULL) {
+		return WERR_GEN_FAILURE;
+	}
+
+	msg = ldb_msg_new(tmp_ctx);
+	W_ERROR_HAVE_NO_MEMORY(msg);
+
+	msg->dn = zone_dn;
+	ret = ldb_msg_add_string(msg, "objectClass", "dnsZone");
+	if (ret != LDB_SUCCESS) {
+		return WERR_NOT_ENOUGH_MEMORY;
+	}
+
+	sd_encoded = talloc_zero(tmp_ctx, DATA_BLOB);
+	W_ERROR_HAVE_NO_MEMORY(sd_encoded);
+
+	ndr_err = ndr_push_struct_blob(sd_encoded, tmp_ctx, secdesc,
+			(ndr_push_flags_fn_t)ndr_push_security_descriptor);
+	if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+		return WERR_GEN_FAILURE;
+	}
+
+	ret = ldb_msg_add_steal_value(msg, "nTSecurityDescriptor", sd_encoded);
+	if (ret != LDB_SUCCESS) {
+		return WERR_NOT_ENOUGH_MEMORY;
+	}
+
+	/* dns zone Properties */
+	prop = talloc_zero(tmp_ctx, struct dnsp_DnsProperty);
+	W_ERROR_HAVE_NO_MEMORY(prop);
+
+	prop->version = 1;
+
+	/* zone type */
+	prop->id = DSPROPERTY_ZONE_TYPE;
+	prop->data.zone_type = z->zoneinfo->dwZoneType;
+	if (!dnsserver_db_msg_add_dnsproperty(tmp_ctx, msg, prop)) {
+		return WERR_NOT_ENOUGH_MEMORY;
+	}
+
+	/* allow update */
+	prop->id = DSPROPERTY_ZONE_ALLOW_UPDATE;
+	prop->data.allow_update_flag = z->zoneinfo->fAllowUpdate;
+	if (!dnsserver_db_msg_add_dnsproperty(tmp_ctx, msg, prop)) {
+		return WERR_NOT_ENOUGH_MEMORY;
+	}
+
+	/* secure time */
+	prop->id = DSPROPERTY_ZONE_SECURE_TIME;
+	prop->data.zone_secure_time = 0;
+	if (!dnsserver_db_msg_add_dnsproperty(tmp_ctx, msg, prop)) {
+		return WERR_NOT_ENOUGH_MEMORY;
+	}
+
+	/* norefresh interval */
+	prop->id = DSPROPERTY_ZONE_NOREFRESH_INTERVAL;
+	prop->data.norefresh_hours = 168;
+	if (!dnsserver_db_msg_add_dnsproperty(tmp_ctx, msg, prop)) {
+		return WERR_NOT_ENOUGH_MEMORY;
+	}
+
+	/* refresh interval */
+	prop->id = DSPROPERTY_ZONE_REFRESH_INTERVAL;
+	prop->data.refresh_hours = 168;
+	if (!dnsserver_db_msg_add_dnsproperty(tmp_ctx, msg, prop)) {
+		return WERR_NOT_ENOUGH_MEMORY;
+	}
+
+	/* aging state */
+	prop->id = DSPROPERTY_ZONE_AGING_STATE;
+	prop->data.aging_enabled = z->zoneinfo->fAging;
+	if (!dnsserver_db_msg_add_dnsproperty(tmp_ctx, msg, prop)) {
+		return WERR_NOT_ENOUGH_MEMORY;
+	}
+
+	/* aging enabled time */
+	prop->id = DSPROPERTY_ZONE_AGING_ENABLED_TIME;
+	prop->data.next_scavenging_cycle_hours = 0;
+	if (!dnsserver_db_msg_add_dnsproperty(tmp_ctx, msg, prop)) {
+		return WERR_NOT_ENOUGH_MEMORY;
+	}
+
+	talloc_free(prop);
+
+	ret = ldb_add(samdb, msg);
+	if (ret != LDB_SUCCESS) {
+		DEBUG(0, ("dnsserver: Failed to create zone (%s): %s\n",
+		      z->name, ldb_errstring(samdb)));
+
+		if (ret == LDB_ERR_INSUFFICIENT_ACCESS_RIGHTS) {
+			return WERR_ACCESS_DENIED;
+		}
+
+		return WERR_INTERNAL_DB_ERROR;
+	}
+
+	return WERR_OK;
+}
+
+
+/* Create new dnsZone record and @ record (SOA + NS) */
+WERROR dnsserver_db_create_zone(struct ldb_context *samdb,
+				struct dnsserver_partition *partitions,
+				struct dnsserver_zone *zone,
+				struct loadparm_context *lp_ctx)
+{
+	struct dnsserver_partition *p;
+	bool in_forest = false;
+	WERROR status;
+	struct ldb_dn *dn;
+	TALLOC_CTX *tmp_ctx;
+	struct dnsp_DnssrvRpcRecord *dns_rec;
+	struct dnsp_soa soa;
+	char *tmpstr, *server_fqdn, *soa_email;
+	struct ldb_val name_val = data_blob_string_const(zone->name);
+
+	/* We only support primary zones for now */
+	if (zone->zoneinfo->dwZoneType != DNS_ZONE_TYPE_PRIMARY) {
+		return WERR_CALL_NOT_IMPLEMENTED;
+	}
+
+	/* Get the correct partition */
+	if (zone->partition->dwDpFlags & DNS_DP_FOREST_DEFAULT) {
+		in_forest = true;
+	}
+	for (p = partitions; p; p = p->next) {
+		if (in_forest == p->is_forest) {
+			break;
+		}
+	}
+	if (p == NULL) {
+		return WERR_DNS_ERROR_DP_DOES_NOT_EXIST;
+	}
+
+	tmp_ctx = talloc_new(NULL);
+	W_ERROR_HAVE_NO_MEMORY(tmp_ctx);
+
+	dn = ldb_dn_copy(tmp_ctx, p->partition_dn);
+	W_ERROR_HAVE_NO_MEMORY_AND_FREE(dn, tmp_ctx);
+
+	if (!ldb_dn_add_child_fmt(dn, "CN=MicrosoftDNS")) {
+		talloc_free(tmp_ctx);
+		return WERR_NOT_ENOUGH_MEMORY;
+	}
+
+	if (!ldb_dn_add_child_val(dn, "DC", name_val)) {
+		talloc_free(tmp_ctx);
+		return WERR_NOT_ENOUGH_MEMORY;
+	}
+
+	/* Add dnsZone record */
+	status = dnsserver_db_do_create_zone(tmp_ctx, samdb, dn, zone);
+	if (!W_ERROR_IS_OK(status)) {
+		talloc_free(tmp_ctx);
+		return status;
+	}
+
+	if (!ldb_dn_add_child_fmt(dn, "DC=@")) {
+		talloc_free(tmp_ctx);
+		return WERR_NOT_ENOUGH_MEMORY;
+	}
+
+	dns_rec = talloc_zero_array(tmp_ctx, struct dnsp_DnssrvRpcRecord, 2);
+	W_ERROR_HAVE_NO_MEMORY_AND_FREE(dns_rec, tmp_ctx);
+
+	tmpstr = talloc_asprintf(tmp_ctx, "%s.%s",
+				 lpcfg_netbios_name(lp_ctx),
+				 lpcfg_realm(lp_ctx));
+	W_ERROR_HAVE_NO_MEMORY_AND_FREE(tmpstr, tmp_ctx);
+	server_fqdn = strlower_talloc(tmp_ctx, tmpstr);
+	W_ERROR_HAVE_NO_MEMORY_AND_FREE(server_fqdn, tmp_ctx);
+	talloc_free(tmpstr);
+
+	tmpstr = talloc_asprintf(tmp_ctx, "hostmaster.%s",
+				  lpcfg_realm(lp_ctx));
+	W_ERROR_HAVE_NO_MEMORY_AND_FREE(tmpstr, tmp_ctx);
+	soa_email = strlower_talloc(tmp_ctx, tmpstr);
+	W_ERROR_HAVE_NO_MEMORY_AND_FREE(soa_email, tmp_ctx);
+	talloc_free(tmpstr);
+
+	/* SOA Record - values same as defined in provision/sambadns.py */
+	soa.serial = 1;
+	soa.refresh = 900;
+	soa.retry = 600;
+	soa.expire = 86400;
+	soa.minimum = 3600;
+	soa.mname = server_fqdn;
+	soa.rname = soa_email;
+
+	dns_rec[0].wType = DNS_TYPE_SOA;
+	dns_rec[0].rank = DNS_RANK_ZONE;
+	dns_rec[0].dwSerial = soa.serial;
+	dns_rec[0].dwTtlSeconds = 3600;
+	dns_rec[0].dwTimeStamp = 0;
+	dns_rec[0].data.soa = soa;
+
+	/* NS Record */
+	dns_rec[1].wType = DNS_TYPE_NS;
+	dns_rec[1].rank = DNS_RANK_ZONE;
+	dns_rec[1].dwSerial = soa.serial;
+	dns_rec[1].dwTtlSeconds = 3600;
+	dns_rec[1].dwTimeStamp = 0;
+	dns_rec[1].data.ns = server_fqdn;
+
+	/* Add @ Record */
+	status = dnsserver_db_do_add_rec(tmp_ctx, samdb, dn, 2, dns_rec);
+
+	talloc_free(tmp_ctx);
+	return status;
+}
+
+
+/* Delete dnsZone record and all DNS records in the zone */
+WERROR dnsserver_db_delete_zone(struct ldb_context *samdb,
+				struct dnsserver_zone *zone)
+{
+	int ret;
+
+	ret = ldb_transaction_start(samdb);
+	if (ret != LDB_SUCCESS) {
+		return WERR_INTERNAL_DB_ERROR;
+	}
+
+	ret = dsdb_delete(samdb, zone->zone_dn, DSDB_TREE_DELETE);
+	if (ret != LDB_SUCCESS) {
+		ldb_transaction_cancel(samdb);
+
+		if (ret == LDB_ERR_INSUFFICIENT_ACCESS_RIGHTS) {
+			return WERR_ACCESS_DENIED;
+		}
+		return WERR_INTERNAL_DB_ERROR;
+	}
+
+	ret = ldb_transaction_commit(samdb);
+	if (ret != LDB_SUCCESS) {
+		return WERR_INTERNAL_DB_ERROR;
+	}
+
+	return WERR_OK;
+}
diff --git a/source4/rpc_server/dnsserver/dnsserver.h b/source4/rpc_server/dnsserver/dnsserver.h
new file mode 100644
index 0000000..2e46e7c
--- /dev/null
+++ b/source4/rpc_server/dnsserver/dnsserver.h
@@ -0,0 +1,264 @@
+/*
+   Unix SMB/CIFS implementation.
+
+   DNS Server
+
+   Copyright (C) Amitay Isaacs 2011
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef __DNSSERVER_H__
+#define __DNSSERVER_H__
+
+#include "librpc/gen_ndr/dnsp.h"
+#include "librpc/gen_ndr/dnsserver.h"
+#include "param/param.h"
+#include "ldb.h"
+
+struct dnsserver_serverinfo {
+	uint32_t	dwVersion;
+	uint8_t		fBootMethod;
+	uint8_t		fAdminConfigured;
+	uint8_t		fAllowUpdate;
+	uint8_t		fDsAvailable;
+
+	char *		pszServerName;
+	char *		pszDsContainer;
+
+	uint32_t	dwDsForestVersion;
+	uint32_t	dwDsDomainVersion;
+	uint32_t	dwDsDsaVersion;
+	uint32_t	fReadOnlyDC;
+	char *		pszDomainName;
+	char *		pszForestName;
+	char *		pszDomainDirectoryPartition;
+	char *		pszForestDirectoryPartition;
+
+	struct DNS_ADDR_ARRAY * aipServerAddrs;
+	struct DNS_ADDR_ARRAY * aipListenAddrs;
+	struct IP4_ARRAY * aipForwarders;
+
+	struct IP4_ARRAY * aipLogFilter;
+	char *		pwszLogFilePath;
+
+	uint32_t 	dwLogLevel;
+	uint32_t 	dwDebugLevel;
+	uint32_t 	dwEventLogLevel;
+	uint32_t 	dwLogFileMaxSize;
+
+	uint32_t 	dwForwardTimeout;
+	uint32_t 	dwRpcProtocol;
+	uint32_t 	dwNameCheckFlag;
+	uint32_t 	cAddressAnswerLimit;
+	uint32_t 	dwRecursionRetry;
+	uint32_t 	dwRecursionTimeout;
+	uint32_t 	dwMaxCacheTtl;
+	uint32_t 	dwDsPollingInterval;
+	uint32_t 	dwLocalNetPriorityNetMask;
+
+	uint32_t 	dwScavengingInterval;
+	uint32_t 	dwDefaultRefreshInterval;
+	uint32_t 	dwDefaultNoRefreshInterval;
+	uint32_t 	dwLastScavengeTime;
+
+	uint8_t 	fAutoReverseZones;
+	uint8_t 	fAutoCacheUpdate;
+
+	uint8_t 	fRecurseAfterForwarding;
+	uint8_t 	fForwardDelegations;
+	uint8_t 	fNoRecursion;
+	uint8_t 	fSecureResponses;
+
+	uint8_t 	fRoundRobin;
+	uint8_t 	fLocalNetPriority;
+
+	uint8_t 	fBindSecondaries;
+	uint8_t 	fWriteAuthorityNs;
+
+	uint8_t 	fStrictFileParsing;
+	uint8_t 	fLooseWildcarding;
+	uint8_t 	fDefaultAgingState;
+};
+
+struct dnsserver_zoneinfo {
+	uint8_t		Version;
+	uint32_t	Flags;
+	uint8_t		dwZoneType;
+	uint8_t		fReverse;
+	uint8_t		fAllowUpdate;
+	uint8_t		fPaused;
+	uint8_t		fShutdown;
+	uint8_t		fAutoCreated;
+
+	uint8_t		fUseDatabase;
+	char *		pszDataFile;
+
+	struct IP4_ARRAY * aipMasters;
+
+	uint32_t	fSecureSecondaries;
+	uint32_t	fNotifyLevel;
+	struct IP4_ARRAY * aipSecondaries;
+	struct IP4_ARRAY * aipNotify;
+
+	uint32_t	fUseWins;
+	uint32_t	fUseNbstat;
+
+	uint32_t	fAging;
+	uint32_t	dwNoRefreshInterval;
+	uint32_t	dwRefreshInterval;
+	uint32_t	dwAvailForScavengeTime;
+	struct IP4_ARRAY * aipScavengeServers;
+
+	uint32_t	dwForwarderTimeout;
+	uint32_t	fForwarderSlave;
+
+	struct IP4_ARRAY * aipLocalMasters;
+
+	char *		pwszZoneDn;
+
+	uint32_t	dwLastSuccessfulSoaCheck;
+	uint32_t	dwLastSuccessfulXfr;
+
+	uint32_t	fQueuedForBackgroundLoad;
+	uint32_t	fBackgroundLoadInProgress;
+	uint8_t		fReadOnlyZone;
+
+	uint32_t	dwLastXfrAttempt;
+	uint32_t	dwLastXfrResult;
+};
+
+
+struct dnsserver_partition {
+	struct dnsserver_partition *prev, *next;
+	struct ldb_dn *partition_dn;
+	const char *pszDpFqdn;
+	uint32_t dwDpFlags;
+	bool is_forest;
+	int zones_count;
+};
+
+
+struct dnsserver_partition_info {
+	const char *pszCrDn;
+	uint32_t dwState;
+	uint32_t dwReplicaCount;
+	struct DNS_RPC_DP_REPLICA **ReplicaArray;
+};
+
+
+struct dnsserver_zone {
+	struct dnsserver_zone *prev, *next;
+	struct dnsserver_partition *partition;
+	const char *name;
+	struct ldb_dn *zone_dn;
+	struct dnsserver_zoneinfo *zoneinfo;
+	struct dnsp_DnsProperty *tmp_props;
+	int32_t num_props;
+};
+
+
+struct dns_tree {
+	const char *name;
+	int level;
+	unsigned int num_children;
+	struct dns_tree **children;
+	void *data;
+};
+
+/* Data structure manipulation functions from dnsdata.c */
+
+struct IP4_ARRAY *ip4_array_copy(TALLOC_CTX *mem_ctx, struct IP4_ARRAY *ip4);
+struct DNS_ADDR_ARRAY *ip4_array_to_dns_addr_array(TALLOC_CTX *mem_ctx, struct IP4_ARRAY *ip4);
+struct IP4_ARRAY *dns_addr_array_to_ip4_array(TALLOC_CTX *mem_ctx,
+					      struct DNS_ADDR_ARRAY *ip);
+struct DNS_ADDR_ARRAY *dns_addr_array_copy(TALLOC_CTX *mem_ctx, struct DNS_ADDR_ARRAY *addr);
+
+int dns_split_name_components(TALLOC_CTX *mem_ctx, const char *name, char ***components);
+char *dns_split_node_name(TALLOC_CTX *mem_ctx, const char *node_name, const char *zone_name);
+
+int dns_name_compare(struct ldb_message * const *m1, struct ldb_message * const *m2,
+		     const char *search_name);
+bool dns_record_match(struct dnsp_DnssrvRpcRecord *rec1, struct dnsp_DnssrvRpcRecord *rec2);
+
+void dnsp_to_dns_copy(TALLOC_CTX *mem_ctx, struct dnsp_DnssrvRpcRecord *dnsp,
+			struct DNS_RPC_RECORD *dns);
+WERROR dns_to_dnsp_convert(TALLOC_CTX *mem_ctx, struct DNS_RPC_RECORD *dns,
+			   struct dnsp_DnssrvRpcRecord **out_dnsp,
+			   bool check_name);
+
+struct dns_tree *dns_build_tree(TALLOC_CTX *mem_ctx, const char *name, struct ldb_result *res);
+WERROR dns_fill_records_array(TALLOC_CTX *mem_ctx, struct dnsserver_zone *z,
+			enum dns_record_type record_type,
+			unsigned int select_flag, const char *zone_name,
+			struct ldb_message *msg, int num_children,
+			struct DNS_RPC_RECORDS_ARRAY *recs,
+			char ***add_names, int *add_count);
+
+
+/* Utility functions from dnsutils.c */
+
+struct dnsserver_serverinfo *dnsserver_init_serverinfo(TALLOC_CTX *mem_ctx,
+					struct loadparm_context *lp_ctx,
+					struct ldb_context *samdb);
+struct dnsserver_zoneinfo *dnsserver_init_zoneinfo(struct dnsserver_zone *zone,
+					struct dnsserver_serverinfo *serverinfo);
+struct dnsserver_zone *dnsserver_find_zone(struct dnsserver_zone *zones,
+					const char *zone_name);
+struct ldb_dn *dnsserver_name_to_dn(TALLOC_CTX *mem_ctx, struct dnsserver_zone *z,
+					const char *name);
+uint32_t dnsserver_zone_to_request_filter(const char *zone);
+
+/* Database functions from dnsdb.c */
+
+struct dnsserver_partition *dnsserver_db_enumerate_partitions(TALLOC_CTX *mem_ctx,
+					struct dnsserver_serverinfo *serverinfo,
+					struct ldb_context *samdb);
+struct dnsserver_zone *dnsserver_db_enumerate_zones(TALLOC_CTX *mem_ctx,
+					struct ldb_context *samdb,
+					struct dnsserver_partition *p);
+struct dnsserver_partition_info *dnsserver_db_partition_info(TALLOC_CTX *mem_ctx,
+					struct ldb_context *samdb,
+					struct dnsserver_partition *p);
+WERROR dnsserver_db_add_empty_node(TALLOC_CTX *mem_ctx,
+					struct ldb_context *samdb,
+					struct dnsserver_zone *z,
+					const char *node_name);
+WERROR dnsserver_db_add_record(TALLOC_CTX *mem_ctx,
+					struct ldb_context *samdb,
+					struct dnsserver_zone *z,
+					const char *node_name,
+					struct DNS_RPC_RECORD *add_record);
+WERROR dnsserver_db_update_record(TALLOC_CTX *mem_ctx,
+					struct ldb_context *samdb,
+					struct dnsserver_zone *z,
+					const char *node_name,
+					struct DNS_RPC_RECORD *add_record,
+					struct DNS_RPC_RECORD *del_record);
+WERROR dnsserver_db_do_reset_dword(struct ldb_context *samdb,
+					struct dnsserver_zone *z,
+					struct DNS_RPC_NAME_AND_PARAM *n_p);
+WERROR dnsserver_db_delete_record(TALLOC_CTX *mem_ctx,
+				  struct ldb_context *samdb,
+				  struct dnsserver_zone *z,
+				  const char *node_name,
+				  struct DNS_RPC_RECORD *del_record);
+WERROR dnsserver_db_create_zone(struct ldb_context *samdb,
+				struct dnsserver_partition *partitions,
+				struct dnsserver_zone *z,
+				struct loadparm_context *lp_ctx);
+WERROR dnsserver_db_delete_zone(struct ldb_context *samdb,
+				struct dnsserver_zone *z);
+
+#endif /* __DNSSERVER_H__ */
diff --git a/source4/rpc_server/dnsserver/dnsutils.c b/source4/rpc_server/dnsserver/dnsutils.c
new file mode 100644
index 0000000..2c56946
--- /dev/null
+++ b/source4/rpc_server/dnsserver/dnsutils.c
@@ -0,0 +1,414 @@
+/*
+   Unix SMB/CIFS implementation.
+
+   DNS Server
+
+   Copyright (C) Amitay Isaacs 2011
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "includes.h"
+#include "dnsserver.h"
+#include "rpc_server/common/common.h"
+#include "dns_server/dnsserver_common.h"
+#include "dsdb/samdb/samdb.h"
+#include "lib/socket/netif.h"
+#include "lib/util/util_net.h"
+#include "dnsserver_common.h"
+
+#undef strcasecmp
+
+static struct DNS_ADDR_ARRAY *fill_dns_addr_array(TALLOC_CTX *mem_ctx,
+					   struct loadparm_context *lp_ctx,
+					   bool listen_only)
+{
+	struct interface *ifaces;
+	int num_interfaces, i;
+	struct DNS_ADDR_ARRAY *dns_addr_array;
+	const char *ipstr;
+	bool have_ipv4, have_ipv6;
+	uint16_t family;
+
+	have_ipv4 = have_ipv6 = false;
+
+	if (!listen_only) {
+		/*
+		  Return all interfaces from kernel
+		  Not implemented!
+		*/
+		return NULL;
+	}
+
+	/* Only the used interfaces */
+	load_interface_list(mem_ctx, lp_ctx, &ifaces);
+	num_interfaces = iface_list_count(ifaces);
+
+	dns_addr_array = talloc_zero(mem_ctx, struct DNS_ADDR_ARRAY);
+	if (dns_addr_array == NULL) {
+		goto nomem;
+	}
+	dns_addr_array->MaxCount = num_interfaces;
+	dns_addr_array->AddrCount = num_interfaces;
+	if (num_interfaces == 0) {
+		goto nomem;
+	}
+
+	dns_addr_array->AddrArray = talloc_zero_array(mem_ctx, struct DNS_ADDR,
+						      num_interfaces);
+	if (!dns_addr_array->AddrArray) {
+		TALLOC_FREE(dns_addr_array);
+		goto nomem;
+	}
+
+	for (i = 0; i < num_interfaces; i++) {
+		int ret;
+		ipstr = iface_list_n_ip(ifaces, i);
+		if (is_ipaddress_v4(ipstr)) {
+			have_ipv4 = true;
+			dns_addr_array->AddrArray[i].MaxSa[0] = 0x02;
+			ret = inet_pton(AF_INET, ipstr,
+					&dns_addr_array->AddrArray[i].MaxSa[4]);
+		} else {
+			have_ipv6 = true;
+			dns_addr_array->AddrArray[i].MaxSa[0] = 0x17;
+			ret = inet_pton(AF_INET6, ipstr,
+					&dns_addr_array->AddrArray[i].MaxSa[8]);
+		}
+		if (ret != 1) { /*yep, 1 means success for inet_pton */
+			DBG_ERR("Interface %d address (%s) is invalid\n",
+				i, ipstr);
+			goto nomem;
+		}
+	}
+
+	if (have_ipv4 && have_ipv6) {
+		family = 0;   /* mixed: MS-DNSP */
+	} else if (have_ipv4 && !have_ipv6) {
+		family = AF_INET;
+	} else {
+		family = AF_INET6;
+	}
+	dns_addr_array->Family = family;
+
+nomem:
+	talloc_free(ifaces);
+	return dns_addr_array;
+}
+
+struct dnsserver_serverinfo *dnsserver_init_serverinfo(TALLOC_CTX *mem_ctx,
+							struct loadparm_context *lp_ctx,
+							struct ldb_context *samdb)
+{
+	struct dnsserver_serverinfo *serverinfo;
+	struct dcerpc_server_info *dinfo;
+	struct ldb_dn *domain_dn, *forest_dn;
+
+	serverinfo = talloc_zero(mem_ctx, struct dnsserver_serverinfo);
+	if (serverinfo == NULL) {
+		return NULL;
+	}
+
+	dinfo = lpcfg_dcerpc_server_info(mem_ctx, lp_ctx);
+	if (dinfo) {
+		serverinfo->dwVersion = (dinfo->version_build & 0x0000FFFF) << 16 |
+				(dinfo->version_minor & 0x000000FF) << 8 |
+				(dinfo->version_major & 0x000000FF);
+		talloc_free(dinfo);
+	} else {
+		serverinfo->dwVersion = 0x0ECE0205; /* build, os_minor, os_major */;
+	}
+
+	serverinfo->fBootMethod = DNS_BOOT_METHOD_DIRECTORY;
+	serverinfo->fAdminConfigured = 0;
+	serverinfo->fAllowUpdate = 1;
+	serverinfo->fDsAvailable = 1;
+
+	serverinfo->pszServerName = talloc_asprintf(mem_ctx, "%s.%s",
+					lpcfg_netbios_name(lp_ctx),
+					lpcfg_dnsdomain(lp_ctx));
+
+	domain_dn = ldb_get_default_basedn(samdb);
+	forest_dn = ldb_get_root_basedn(samdb);
+
+	serverinfo->pszDsContainer = talloc_asprintf(mem_ctx,
+					"CN=MicrosoftDNS,DC=DomainDnsZones,%s",
+					ldb_dn_get_linearized(domain_dn));
+
+	serverinfo->dwDsForestVersion = dsdb_forest_functional_level(samdb);
+	serverinfo->dwDsDomainVersion = dsdb_functional_level(samdb);
+	serverinfo->dwDsDsaVersion = dsdb_dc_functional_level(samdb);
+
+	serverinfo->pszDomainName = samdb_dn_to_dns_domain(mem_ctx, domain_dn);
+	serverinfo->pszForestName = samdb_dn_to_dns_domain(mem_ctx, forest_dn);
+
+	serverinfo->pszDomainDirectoryPartition = talloc_asprintf(mem_ctx,
+							"DC=DomainDnsZones,%s",
+							ldb_dn_get_linearized(domain_dn));
+	serverinfo->pszForestDirectoryPartition = talloc_asprintf(mem_ctx,
+							"DC=ForestDnsZones,%s",
+							ldb_dn_get_linearized(forest_dn));
+	/* IP addresses on which the DNS server listens for DNS requests */
+	serverinfo->aipListenAddrs = fill_dns_addr_array(mem_ctx, lp_ctx, true);
+
+	/* All IP addresses available on the server
+	 * Not implemented!
+	 * Use same as listen addresses
+	 */
+	serverinfo->aipServerAddrs = serverinfo->aipListenAddrs;
+
+	serverinfo->aipForwarders = NULL;
+
+	serverinfo->aipLogFilter = NULL;
+	serverinfo->pwszLogFilePath = NULL;
+
+	serverinfo->dwLogLevel = 0;
+	serverinfo->dwDebugLevel = 0;
+	serverinfo->dwEventLogLevel = DNS_EVENT_LOG_INFORMATION_TYPE;
+	serverinfo->dwLogFileMaxSize = 0;
+
+	serverinfo->dwForwardTimeout = 3; /* seconds (default) */
+	serverinfo->dwRpcProtocol = 5;
+	serverinfo->dwNameCheckFlag = DNS_ALLOW_MULTIBYTE_NAMES;
+	serverinfo->cAddressAnswerLimit = 0;
+	serverinfo->dwRecursionRetry = 3;       /* seconds (default) */
+	serverinfo->dwRecursionTimeout = 8;     /* seconds (default) */
+	serverinfo->dwMaxCacheTtl = 0x00015180; /* 1 day (default) */
+	serverinfo->dwDsPollingInterval = 0xB4; /* 3 minutes (default) */
+	serverinfo->dwLocalNetPriorityNetMask = 0x000000FF;
+
+	serverinfo->dwScavengingInterval = lpcfg_parm_int(
+	    lp_ctx, NULL, "dnsserver", "ScavengingInterval", 24 * 7);
+	serverinfo->dwDefaultRefreshInterval = lpcfg_parm_int(
+	    lp_ctx, NULL, "dnsserver", "DefaultRefreshInterval", 24 * 3);
+	serverinfo->dwDefaultNoRefreshInterval = lpcfg_parm_int(
+	    lp_ctx, NULL, "dnsserver", "DefaultNoRefreshInterval", 24 * 3);
+
+	serverinfo->dwLastScavengeTime = 0;
+
+	serverinfo->fAutoReverseZones = 0;
+	serverinfo->fAutoCacheUpdate = 0;
+
+	serverinfo->fRecurseAfterForwarding = 0;
+	serverinfo->fForwardDelegations = 1;
+	serverinfo->fNoRecursion = 0;
+	serverinfo->fSecureResponses = 0;
+
+	serverinfo->fRoundRobin = 1;
+	serverinfo->fLocalNetPriority = 0;
+
+	serverinfo->fBindSecondaries = 0;
+	serverinfo->fWriteAuthorityNs = 0;
+
+	serverinfo->fStrictFileParsing = 0;
+	serverinfo->fLooseWildcarding = 0 ;
+	serverinfo->fDefaultAgingState = 0;
+
+	return serverinfo;
+}
+
+struct dnsserver_zoneinfo *dnsserver_init_zoneinfo(struct dnsserver_zone *zone,
+						struct dnsserver_serverinfo *serverinfo)
+{
+	struct dnsserver_zoneinfo *zoneinfo;
+	uint32_t fReverse;
+	const char *revzone = "in-addr.arpa";
+	const char *revzone6 = "ip6.arpa";
+	int len1, len2;
+	unsigned int i = 0;
+
+	zoneinfo = talloc_zero(zone, struct dnsserver_zoneinfo);
+	if (zoneinfo == NULL) {
+		return NULL;
+	}
+
+	/* If the zone name ends with in-addr.arpa, it's reverse zone */
+	/* If the zone name ends with ip6.arpa, it's reverse zone (IPv6) */
+	fReverse = 0;
+	len1 = strlen(zone->name);
+	len2 = strlen(revzone);
+	if (len1 > len2 && strcasecmp(&zone->name[len1-len2], revzone) == 0) {
+		fReverse = 1;
+	} else {
+		len2 = strlen(revzone6);
+		if (len1 > len2 && strcasecmp(&zone->name[len1-len2], revzone6) == 0) {
+			fReverse = 1;
+		}
+	}
+
+	zoneinfo->Version = 0x32;
+	zoneinfo->Flags = DNS_RPC_ZONE_DSINTEGRATED;
+
+	if (strcmp(zone->name, ".") == 0) {
+		zoneinfo->dwZoneType = DNS_ZONE_TYPE_CACHE;
+		zoneinfo->fAllowUpdate = DNS_ZONE_UPDATE_OFF;
+		zoneinfo->fSecureSecondaries = DNS_ZONE_SECSECURE_NO_SECURITY;
+		zoneinfo->fNotifyLevel = DNS_ZONE_NOTIFY_OFF;
+		zoneinfo->dwNoRefreshInterval = 0;
+		zoneinfo->dwRefreshInterval = 0;
+	} else {
+		zoneinfo->Flags |= DNS_RPC_ZONE_UPDATE_SECURE;
+		zoneinfo->dwZoneType = DNS_ZONE_TYPE_PRIMARY;
+		zoneinfo->fAllowUpdate = DNS_ZONE_UPDATE_SECURE;
+		zoneinfo->fSecureSecondaries = DNS_ZONE_SECSECURE_NO_XFER;
+		zoneinfo->fNotifyLevel = DNS_ZONE_NOTIFY_LIST_ONLY;
+		zoneinfo->dwNoRefreshInterval = serverinfo->dwDefaultNoRefreshInterval;
+		zoneinfo->dwRefreshInterval = serverinfo->dwDefaultRefreshInterval;
+	}
+
+	zoneinfo->fReverse = fReverse;
+	zoneinfo->fPaused = 0;
+	zoneinfo->fShutdown = 0;
+	zoneinfo->fAutoCreated = 0;
+	zoneinfo->fUseDatabase = 1;
+	zoneinfo->pszDataFile = NULL;
+	zoneinfo->aipMasters = NULL;
+	zoneinfo->aipSecondaries = NULL;
+	zoneinfo->aipNotify = NULL;
+	zoneinfo->fUseWins = 0;
+	zoneinfo->fUseNbstat = 0;
+	zoneinfo->fAging = 0;
+	zoneinfo->dwAvailForScavengeTime = 0;
+	zoneinfo->aipScavengeServers = NULL;
+	zoneinfo->dwForwarderTimeout = 0;
+	zoneinfo->fForwarderSlave = 0;
+	zoneinfo->aipLocalMasters = NULL;
+	zoneinfo->pwszZoneDn = discard_const_p(char, ldb_dn_get_linearized(zone->zone_dn));
+	zoneinfo->dwLastSuccessfulSoaCheck = 0;
+	zoneinfo->dwLastSuccessfulXfr = 0;
+	zoneinfo->fQueuedForBackgroundLoad = 0;
+	zoneinfo->fBackgroundLoadInProgress = 0;
+	zoneinfo->fReadOnlyZone = 0;
+	zoneinfo->dwLastXfrAttempt = 0;
+	zoneinfo->dwLastXfrResult = 0;
+
+	for(i=0; i<zone->num_props; i++){
+		bool valid_property;
+		valid_property = dns_zoneinfo_load_zone_property(
+		    zoneinfo, &zone->tmp_props[i]);
+		if (!valid_property) {
+			TALLOC_FREE(zoneinfo);
+			return NULL;
+		}
+	}
+
+	return zoneinfo;
+}
+
+struct dnsserver_zone *dnsserver_find_zone(struct dnsserver_zone *zones, const char *zone_name)
+{
+	struct dnsserver_zone *z = NULL;
+
+	for (z = zones; z; z = z->next) {
+		if (samba_dns_name_equal(zone_name, z->name)) {
+			break;
+		}
+	}
+
+	return z;
+}
+
+struct ldb_dn *dnsserver_name_to_dn(TALLOC_CTX *mem_ctx, struct dnsserver_zone *z, const char *name)
+{
+	struct ldb_dn *dn;
+	bool ret;
+	struct ldb_val name_val =
+		data_blob_string_const(name);
+
+	dn = ldb_dn_copy(mem_ctx, z->zone_dn);
+	if (dn == NULL) {
+		return NULL;
+	}
+	if (strcasecmp(name, z->name) == 0) {
+		ret = ldb_dn_add_child_fmt(dn, "DC=@");
+		if (!ret) {
+			talloc_free(dn);
+			return NULL;
+		}
+		return dn;
+	}
+
+	ret = ldb_dn_add_child_val(dn,
+				   "DC",
+				   name_val);
+
+	if (!ret) {
+		talloc_free(dn);
+		return NULL;
+	}
+
+	return dn;
+}
+
+uint32_t dnsserver_zone_to_request_filter(const char *zone_name)
+{
+	uint32_t request_filter = 0;
+
+	if (strcmp(zone_name, "..AllZones") == 0) {
+		request_filter = DNS_ZONE_REQUEST_PRIMARY
+			| DNS_ZONE_REQUEST_SECONDARY
+			| DNS_ZONE_REQUEST_AUTO
+			| DNS_ZONE_REQUEST_FORWARD
+			| DNS_ZONE_REQUEST_REVERSE
+			| DNS_ZONE_REQUEST_FORWARDER
+			| DNS_ZONE_REQUEST_STUB
+			| DNS_ZONE_REQUEST_DS
+			| DNS_ZONE_REQUEST_NON_DS
+			| DNS_ZONE_REQUEST_DOMAIN_DP
+			| DNS_ZONE_REQUEST_FOREST_DP
+			| DNS_ZONE_REQUEST_CUSTOM_DP
+			| DNS_ZONE_REQUEST_LEGACY_DP;
+	} else if (strcmp(zone_name, "..AllZonesAndCache") == 0) {
+		request_filter = DNS_ZONE_REQUEST_PRIMARY
+			| DNS_ZONE_REQUEST_SECONDARY
+			| DNS_ZONE_REQUEST_CACHE
+			| DNS_ZONE_REQUEST_AUTO
+			| DNS_ZONE_REQUEST_FORWARD
+			| DNS_ZONE_REQUEST_REVERSE
+			| DNS_ZONE_REQUEST_FORWARDER
+			| DNS_ZONE_REQUEST_STUB
+			| DNS_ZONE_REQUEST_DS
+			| DNS_ZONE_REQUEST_NON_DS
+			| DNS_ZONE_REQUEST_DOMAIN_DP
+			| DNS_ZONE_REQUEST_FOREST_DP
+			| DNS_ZONE_REQUEST_CUSTOM_DP
+			| DNS_ZONE_REQUEST_LEGACY_DP;
+	} else if (strcmp(zone_name, "..AllPrimaryZones") == 0) {
+		request_filter = DNS_ZONE_REQUEST_PRIMARY;
+	} else if (strcmp(zone_name, "..AllSecondaryZones") == 0) {
+		request_filter = DNS_ZONE_REQUEST_SECONDARY;
+	} else if (strcmp(zone_name, "..AllForwardZones") == 0) {
+		request_filter = DNS_ZONE_REQUEST_FORWARD;
+	} else if (strcmp(zone_name, "..AllReverseZones") == 0) {
+		request_filter = DNS_ZONE_REQUEST_REVERSE;
+	} else if (strcmp(zone_name, "..AllDsZones") == 0) {
+		request_filter = DNS_ZONE_REQUEST_DS;
+	} else if (strcmp(zone_name, "..AllNonDsZones") == 0) {
+		request_filter = DNS_ZONE_REQUEST_NON_DS;
+	} else if (strcmp(zone_name, "..AllPrimaryReverseZones") == 0) {
+		request_filter = DNS_ZONE_REQUEST_PRIMARY
+			| DNS_ZONE_REQUEST_REVERSE;
+	} else if (strcmp(zone_name, "..AllPrimaryForwardZones") == 0) {
+		request_filter = DNS_ZONE_REQUEST_PRIMARY
+			| DNS_ZONE_REQUEST_FORWARD;
+	} else if (strcmp(zone_name, "..AllSecondaryReverseZones") == 0) {
+		request_filter = DNS_ZONE_REQUEST_SECONDARY
+			| DNS_ZONE_REQUEST_REVERSE;
+	} else if (strcmp(zone_name, "..AllSecondaryForwardZones") == 0) {
+		request_filter = DNS_ZONE_REQUEST_SECONDARY
+			| DNS_ZONE_REQUEST_REVERSE;
+	}
+
+	return request_filter;
+}