2 Unix SMB/CIFS implementation.
4 DNS server handler for update requests
6 Copyright (C) 2010 Kai Blin <kai@samba.org>
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>.
23 #include "libcli/util/ntstatus.h"
24 #include "librpc/ndr/libndr.h"
25 #include "librpc/gen_ndr/ndr_dns.h"
26 #include "librpc/gen_ndr/ndr_dnsp.h"
28 #include "param/param.h"
29 #include "param/loadparm.h"
30 #include "dsdb/samdb/samdb.h"
31 #include "dsdb/common/util.h"
32 #include "samba/service_task.h"
33 #include "dns_server/dns_server.h"
34 #include "auth/auth.h"
37 #define DBGC_CLASS DBGC_DNS
39 static WERROR dns_rr_to_dnsp(TALLOC_CTX *mem_ctx,
40 const struct dns_res_rec *rrec,
41 struct dnsp_DnssrvRpcRecord *r,
44 static WERROR check_one_prerequisite(struct dns_server *dns,
46 const struct dns_name_question *zone,
47 const struct dns_res_rec *pr,
55 struct dnsp_DnssrvRpcRecord *rec = NULL;
56 struct dnsp_DnssrvRpcRecord *ans;
59 size_t host_part_len = 0;
64 return DNS_ERR(FORMAT_ERROR);
67 match = dns_name_match(zone->name, pr->name, &host_part_len);
69 return DNS_ERR(NOTZONE);
72 werror = dns_name2dn(dns, mem_ctx, pr->name, &dn);
73 W_ERROR_NOT_OK_RETURN(werror);
75 if (pr->rr_class == DNS_QCLASS_ANY) {
77 if (pr->length != 0) {
78 return DNS_ERR(FORMAT_ERROR);
82 if (pr->rr_type == DNS_QTYPE_ALL) {
85 werror = dns_lookup_records(dns, mem_ctx, dn, &ans, &a_count);
86 if (W_ERROR_EQUAL(werror, WERR_DNS_ERROR_NAME_DOES_NOT_EXIST)) {
87 return DNS_ERR(NAME_ERROR);
89 W_ERROR_NOT_OK_RETURN(werror);
92 return DNS_ERR(NAME_ERROR);
97 werror = dns_lookup_records(dns, mem_ctx, dn, &ans, &a_count);
98 if (W_ERROR_EQUAL(werror, WERR_DNS_ERROR_NAME_DOES_NOT_EXIST)) {
99 return DNS_ERR(NXRRSET);
101 if (W_ERROR_EQUAL(werror, DNS_ERR(NAME_ERROR))) {
102 return DNS_ERR(NXRRSET);
104 W_ERROR_NOT_OK_RETURN(werror);
106 for (i = 0; i < a_count; i++) {
107 if (ans[i].wType == (enum dns_record_type) pr->rr_type) {
113 return DNS_ERR(NXRRSET);
118 * RFC2136 3.2.5 doesn't actually mention the need to return
119 * OK here, but otherwise we'd always return a FORMAT_ERROR
120 * later on. This also matches Microsoft DNS behavior.
125 if (pr->rr_class == DNS_QCLASS_NONE) {
126 if (pr->length != 0) {
127 return DNS_ERR(FORMAT_ERROR);
130 if (pr->rr_type == DNS_QTYPE_ALL) {
133 werror = dns_lookup_records(dns, mem_ctx, dn, &ans, &a_count);
134 if (W_ERROR_EQUAL(werror, WERR_OK)) {
135 return DNS_ERR(YXDOMAIN);
140 werror = dns_lookup_records(dns, mem_ctx, dn, &ans, &a_count);
141 if (W_ERROR_EQUAL(werror, WERR_DNS_ERROR_NAME_DOES_NOT_EXIST)) {
144 if (W_ERROR_EQUAL(werror, DNS_ERR(NAME_ERROR))) {
148 for (i = 0; i < a_count; i++) {
149 if (ans[i].wType == (enum dns_record_type) pr->rr_type) {
155 return DNS_ERR(YXRRSET);
160 * RFC2136 3.2.5 doesn't actually mention the need to return
161 * OK here, but otherwise we'd always return a FORMAT_ERROR
162 * later on. This also matches Microsoft DNS behavior.
167 if (pr->rr_class != zone->question_class) {
168 return DNS_ERR(FORMAT_ERROR);
171 *final_result = false;
173 werror = dns_lookup_records(dns, mem_ctx, dn, &ans, &a_count);
174 if (W_ERROR_EQUAL(werror, WERR_DNS_ERROR_NAME_DOES_NOT_EXIST)) {
175 return DNS_ERR(NXRRSET);
177 if (W_ERROR_EQUAL(werror, DNS_ERR(NAME_ERROR))) {
178 return DNS_ERR(NXRRSET);
180 W_ERROR_NOT_OK_RETURN(werror);
182 rec = talloc_zero(mem_ctx, struct dnsp_DnssrvRpcRecord);
183 W_ERROR_HAVE_NO_MEMORY(rec);
185 werror = dns_rr_to_dnsp(rec, pr, rec, dns_name_is_static(ans, a_count));
186 W_ERROR_NOT_OK_RETURN(werror);
188 for (i = 0; i < a_count; i++) {
189 if (dns_record_match(rec, &ans[i])) {
196 return DNS_ERR(NXRRSET);
202 static WERROR check_prerequisites(struct dns_server *dns,
204 const struct dns_name_question *zone,
205 const struct dns_res_rec *prereqs, uint16_t count)
208 WERROR final_error = WERR_OK;
210 for (i = 0; i < count; i++) {
214 werror = check_one_prerequisite(dns, mem_ctx, zone,
215 &prereqs[i], &final);
216 if (!W_ERROR_IS_OK(werror)) {
220 if (W_ERROR_IS_OK(final_error)) {
221 final_error = werror;
226 if (!W_ERROR_IS_OK(final_error)) {
233 static WERROR update_prescan(const struct dns_name_question *zone,
234 const struct dns_res_rec *updates, uint16_t count)
236 const struct dns_res_rec *r;
238 size_t host_part_len;
241 for (i = 0; i < count; i++) {
243 match = dns_name_match(zone->name, r->name, &host_part_len);
245 return DNS_ERR(NOTZONE);
247 if (zone->question_class == r->rr_class) {
248 if (r->rr_type == DNS_QTYPE_ALL) {
249 return DNS_ERR(FORMAT_ERROR);
251 if (r->rr_type == DNS_QTYPE_AXFR) {
252 return DNS_ERR(FORMAT_ERROR);
254 if (r->rr_type == DNS_QTYPE_MAILB) {
255 return DNS_ERR(FORMAT_ERROR);
257 if (r->rr_type == DNS_QTYPE_MAILA) {
258 return DNS_ERR(FORMAT_ERROR);
260 } else if (r->rr_class == DNS_QCLASS_ANY) {
262 return DNS_ERR(FORMAT_ERROR);
264 if (r->length != 0) {
265 return DNS_ERR(FORMAT_ERROR);
267 if (r->rr_type == DNS_QTYPE_AXFR) {
268 return DNS_ERR(FORMAT_ERROR);
270 if (r->rr_type == DNS_QTYPE_MAILB) {
271 return DNS_ERR(FORMAT_ERROR);
273 if (r->rr_type == DNS_QTYPE_MAILA) {
274 return DNS_ERR(FORMAT_ERROR);
276 } else if (r->rr_class == DNS_QCLASS_NONE) {
278 return DNS_ERR(FORMAT_ERROR);
280 if (r->rr_type == DNS_QTYPE_ALL) {
281 return DNS_ERR(FORMAT_ERROR);
283 if (r->rr_type == DNS_QTYPE_AXFR) {
284 return DNS_ERR(FORMAT_ERROR);
286 if (r->rr_type == DNS_QTYPE_MAILB) {
287 return DNS_ERR(FORMAT_ERROR);
289 if (r->rr_type == DNS_QTYPE_MAILA) {
290 return DNS_ERR(FORMAT_ERROR);
293 return DNS_ERR(FORMAT_ERROR);
299 static WERROR dns_rr_to_dnsp(TALLOC_CTX *mem_ctx,
300 const struct dns_res_rec *rrec,
301 struct dnsp_DnssrvRpcRecord *r,
304 enum ndr_err_code ndr_err;
306 if (rrec->rr_type == DNS_QTYPE_ALL) {
307 return DNS_ERR(FORMAT_ERROR);
312 r->wType = (enum dns_record_type) rrec->rr_type;
313 r->dwTtlSeconds = rrec->ttl;
314 r->rank = DNS_RANK_ZONE;
315 if (name_is_static) {
318 r->dwTimeStamp = unix_to_dns_timestamp(time(NULL));
321 /* If we get QCLASS_ANY, we're done here */
322 if (rrec->rr_class == DNS_QCLASS_ANY) {
326 switch(rrec->rr_type) {
328 r->data.ipv4 = talloc_strdup(mem_ctx, rrec->rdata.ipv4_record);
329 W_ERROR_HAVE_NO_MEMORY(r->data.ipv4);
332 r->data.ipv6 = talloc_strdup(mem_ctx, rrec->rdata.ipv6_record);
333 W_ERROR_HAVE_NO_MEMORY(r->data.ipv6);
336 r->data.ns = talloc_strdup(mem_ctx, rrec->rdata.ns_record);
337 W_ERROR_HAVE_NO_MEMORY(r->data.ns);
339 case DNS_QTYPE_CNAME:
340 r->data.cname = talloc_strdup(mem_ctx, rrec->rdata.cname_record);
341 W_ERROR_HAVE_NO_MEMORY(r->data.cname);
344 r->data.srv.wPriority = rrec->rdata.srv_record.priority;
345 r->data.srv.wWeight = rrec->rdata.srv_record.weight;
346 r->data.srv.wPort = rrec->rdata.srv_record.port;
347 r->data.srv.nameTarget = talloc_strdup(mem_ctx,
348 rrec->rdata.srv_record.target);
349 W_ERROR_HAVE_NO_MEMORY(r->data.srv.nameTarget);
352 r->data.ptr = talloc_strdup(mem_ctx, rrec->rdata.ptr_record);
353 W_ERROR_HAVE_NO_MEMORY(r->data.ptr);
356 r->data.mx.wPriority = rrec->rdata.mx_record.preference;
357 r->data.mx.nameTarget = talloc_strdup(mem_ctx,
358 rrec->rdata.mx_record.exchange);
359 W_ERROR_HAVE_NO_MEMORY(r->data.mx.nameTarget);
362 ndr_err = ndr_dnsp_string_list_copy(mem_ctx,
363 &rrec->rdata.txt_record.txt,
365 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
366 return WERR_NOT_ENOUGH_MEMORY;
371 DEBUG(0, ("Got a qytpe of %d\n", rrec->rr_type));
372 return DNS_ERR(NOT_IMPLEMENTED);
381 static WERROR handle_one_update(struct dns_server *dns,
383 const struct dns_name_question *zone,
384 const struct dns_res_rec *update,
385 const struct dns_server_tkey *tkey)
387 struct dnsp_DnssrvRpcRecord *recs = NULL;
393 bool tombstoned = false;
394 bool needs_add = false;
397 DBG_NOTICE("Looking at record: \n");
398 if (DEBUGLVL(DBGLVL_NOTICE)) {
399 NDR_PRINT_DEBUG(dns_res_rec, discard_const(update));
402 switch (update->rr_type) {
405 case DNS_QTYPE_CNAME:
415 DEBUG(0, ("Can't handle updates of type %u yet\n",
417 return DNS_ERR(NOT_IMPLEMENTED);
420 werror = dns_name2dn(dns, mem_ctx, update->name, &dn);
421 DBG_DEBUG("dns_name2dn(): %s\n", win_errstr(werror));
422 W_ERROR_NOT_OK_RETURN(werror);
424 werror = dns_common_lookup(dns->samdb, mem_ctx, dn,
425 &recs, &rcount, &tombstoned);
426 DBG_DEBUG("dns_common_lookup(): %s\n", win_errstr(werror));
427 if (W_ERROR_EQUAL(werror, WERR_DNS_ERROR_NAME_DOES_NOT_EXIST)) {
431 W_ERROR_NOT_OK_RETURN(werror);
435 * we need to keep the existing tombstone record
438 * There *should* only be a single record of type TOMBSTONE,
439 * but we don't insist.
442 DBG_WARNING("Tombstoned dnsNode has %u records, "
443 "expected 1\n", rcount);
444 if (DEBUGLVL(DBGLVL_WARNING)) {
445 NDR_PRINT_DEBUG(dns_res_rec, discard_const(update));
451 name_is_static = dns_name_is_static(recs, rcount);
453 if (update->rr_class == zone->question_class) {
454 if (update->rr_type == DNS_QTYPE_CNAME) {
456 * If there is a record in the directory
457 * that's not a CNAME, ignore update
459 for (i = first; i < rcount; i++) {
460 if (recs[i].wType != DNS_TYPE_CNAME) {
461 DEBUG(5, ("Skipping update\n"));
467 * There should be no entries besides one CNAME record
468 * per name, so replace everything with the new CNAME
472 recs = talloc_realloc(mem_ctx, recs,
473 struct dnsp_DnssrvRpcRecord, rcount + 1);
474 W_ERROR_HAVE_NO_MEMORY(recs);
476 werror = dns_rr_to_dnsp(
477 recs, update, &recs[rcount], name_is_static);
478 DBG_DEBUG("dns_rr_to_dnsp(CNAME): %s\n", win_errstr(werror));
479 W_ERROR_NOT_OK_RETURN(werror);
482 werror = dns_replace_records(dns, mem_ctx, dn,
483 needs_add, recs, rcount);
484 DBG_DEBUG("dns_replace_records(CNAME): %s\n", win_errstr(werror));
485 W_ERROR_NOT_OK_RETURN(werror);
490 * If there is a CNAME record for this name,
493 for (i = first; i < rcount; i++) {
494 if (recs[i].wType == DNS_TYPE_CNAME) {
495 DEBUG(5, ("Skipping update\n"));
500 if (update->rr_type == DNS_QTYPE_SOA) {
504 * If the zone has no SOA record?? or update's
505 * serial number is smaller than existing SOA's,
508 for (i = first; i < rcount; i++) {
509 if (recs[i].wType == DNS_TYPE_SOA) {
512 n = update->rdata.soa_record.serial;
513 o = recs[i].data.soa.serial;
515 * TODO: Implement RFC 1982 comparison
519 DEBUG(5, ("Skipping update\n"));
527 DEBUG(5, ("Skipping update\n"));
531 werror = dns_rr_to_dnsp(
532 mem_ctx, update, &recs[i], name_is_static);
533 DBG_DEBUG("dns_rr_to_dnsp(SOA): %s\n", win_errstr(werror));
534 W_ERROR_NOT_OK_RETURN(werror);
537 * There should only be one SOA, which we have already
538 * found and replaced. We now check for and tombstone
541 for (i++; i < rcount; i++) {
542 if (recs[i].wType != DNS_TYPE_SOA) {
545 DBG_ERR("Duplicate SOA records found.\n");
546 if (DEBUGLVL(DBGLVL_ERR)) {
547 NDR_PRINT_DEBUG(dns_res_rec,
548 discard_const(update));
550 recs[i] = (struct dnsp_DnssrvRpcRecord) {
551 .wType = DNS_TYPE_TOMBSTONE,
555 werror = dns_replace_records(dns, mem_ctx, dn,
556 needs_add, recs, rcount);
557 DBG_DEBUG("dns_replace_records(SOA): %s\n", win_errstr(werror));
558 W_ERROR_NOT_OK_RETURN(werror);
562 /* All but CNAME, SOA */
563 recs = talloc_realloc(mem_ctx, recs,
564 struct dnsp_DnssrvRpcRecord, rcount+1);
565 W_ERROR_HAVE_NO_MEMORY(recs);
568 dns_rr_to_dnsp(recs, update, &recs[rcount], name_is_static);
569 DBG_DEBUG("dns_rr_to_dnsp(GENERIC): %s\n", win_errstr(werror));
570 W_ERROR_NOT_OK_RETURN(werror);
572 for (i = first; i < rcount; i++) {
573 if (!dns_record_match(&recs[i], &recs[rcount])) {
577 recs[i].data = recs[rcount].data;
578 recs[i].wType = recs[rcount].wType;
579 recs[i].dwTtlSeconds = recs[rcount].dwTtlSeconds;
580 recs[i].rank = recs[rcount].rank;
581 recs[i].dwReserved = 0;
583 werror = dns_replace_records(dns, mem_ctx, dn,
584 needs_add, recs, rcount);
585 DBG_DEBUG("dns_replace_records(REPLACE): %s\n", win_errstr(werror));
586 W_ERROR_NOT_OK_RETURN(werror);
590 /* we did not find a matching record. This is new. */
591 werror = dns_replace_records(dns, mem_ctx, dn,
592 needs_add, recs, rcount+1);
593 DBG_DEBUG("dns_replace_records(ADD): %s\n", win_errstr(werror));
594 W_ERROR_NOT_OK_RETURN(werror);
597 } else if (update->rr_class == DNS_QCLASS_ANY) {
599 * Mass-deleting records by type, which we do by adding a
600 * tombstone with zero timestamp. dns_replace_records() will
601 * work out if the node as a whole needs tombstoning.
603 if (update->rr_type == DNS_QTYPE_ALL) {
604 if (samba_dns_name_equal(update->name, zone->name)) {
605 for (i = first; i < rcount; i++) {
607 if (recs[i].wType == DNS_TYPE_SOA) {
611 if (recs[i].wType == DNS_TYPE_NS) {
615 recs[i] = (struct dnsp_DnssrvRpcRecord) {
616 .wType = DNS_TYPE_TOMBSTONE,
621 for (i = first; i < rcount; i++) {
622 recs[i] = (struct dnsp_DnssrvRpcRecord) {
623 .wType = DNS_TYPE_TOMBSTONE,
628 } else if (samba_dns_name_equal(update->name, zone->name)) {
630 if (update->rr_type == DNS_QTYPE_SOA) {
634 if (update->rr_type == DNS_QTYPE_NS) {
638 for (i = first; i < rcount; i++) {
639 if (recs[i].wType == (enum dns_record_type) update->rr_type) {
640 recs[i] = (struct dnsp_DnssrvRpcRecord) {
641 .wType = DNS_TYPE_TOMBSTONE,
646 werror = dns_replace_records(dns, mem_ctx, dn,
647 needs_add, recs, rcount);
648 DBG_DEBUG("dns_replace_records(DELETE-ANY): %s\n", win_errstr(werror));
649 W_ERROR_NOT_OK_RETURN(werror);
652 } else if (update->rr_class == DNS_QCLASS_NONE) {
653 /* deleting individual records */
654 struct dnsp_DnssrvRpcRecord *del_rec;
656 if (update->rr_type == DNS_QTYPE_SOA) {
659 if (update->rr_type == DNS_QTYPE_NS) {
661 struct dnsp_DnssrvRpcRecord *ns_rec = talloc(mem_ctx,
662 struct dnsp_DnssrvRpcRecord);
663 W_ERROR_HAVE_NO_MEMORY(ns_rec);
665 werror = dns_rr_to_dnsp(
666 ns_rec, update, ns_rec, name_is_static);
667 DBG_DEBUG("dns_rr_to_dnsp(NS): %s\n", win_errstr(werror));
668 W_ERROR_NOT_OK_RETURN(werror);
670 for (i = first; i < rcount; i++) {
671 if (dns_record_match(ns_rec, &recs[i])) {
681 del_rec = talloc(mem_ctx, struct dnsp_DnssrvRpcRecord);
682 W_ERROR_HAVE_NO_MEMORY(del_rec);
685 dns_rr_to_dnsp(del_rec, update, del_rec, name_is_static);
686 DBG_DEBUG("dns_rr_to_dnsp(DELETE-NONE): %s\n", win_errstr(werror));
687 W_ERROR_NOT_OK_RETURN(werror);
689 for (i = first; i < rcount; i++) {
690 if (dns_record_match(del_rec, &recs[i])) {
691 recs[i] = (struct dnsp_DnssrvRpcRecord) {
692 .wType = DNS_TYPE_TOMBSTONE,
697 werror = dns_replace_records(dns, mem_ctx, dn,
698 needs_add, recs, rcount);
699 DBG_DEBUG("dns_replace_records(DELETE-NONE): %s\n", win_errstr(werror));
700 W_ERROR_NOT_OK_RETURN(werror);
706 static WERROR handle_updates(struct dns_server *dns,
708 const struct dns_name_question *zone,
709 const struct dns_res_rec *prereqs, uint16_t pcount,
710 struct dns_res_rec *updates, uint16_t upd_count,
711 struct dns_server_tkey *tkey)
713 struct ldb_dn *zone_dn = NULL;
714 WERROR werror = WERR_OK;
717 TALLOC_CTX *tmp_ctx = talloc_new(mem_ctx);
720 ret = ldb_set_opaque(
724 if (ret != LDB_SUCCESS) {
725 DEBUG(1, ("unable to set session info\n"));
726 werror = DNS_ERR(SERVER_FAILURE);
731 werror = dns_name2dn(dns, tmp_ctx, zone->name, &zone_dn);
732 DBG_DEBUG("dns_name2dn(): %s\n", win_errstr(werror));
733 W_ERROR_NOT_OK_GOTO(werror, failed);
735 ret = ldb_transaction_start(dns->samdb);
736 if (ret != LDB_SUCCESS) {
737 werror = DNS_ERR(SERVER_FAILURE);
741 werror = check_prerequisites(dns, tmp_ctx, zone, prereqs, pcount);
742 W_ERROR_NOT_OK_GOTO(werror, failed);
744 DBG_DEBUG("dns update count is %u\n", upd_count);
746 for (ri = 0; ri < upd_count; ri++) {
747 werror = handle_one_update(dns, tmp_ctx, zone,
749 DBG_DEBUG("handle_one_update(%u): %s\n",
750 ri, win_errstr(werror));
751 W_ERROR_NOT_OK_GOTO(werror, failed);
755 if (W_ERROR_IS_OK(werror)) {
756 ret = ldb_transaction_commit(dns->samdb);
757 if (ret != LDB_SUCCESS) {
758 werror = DNS_ERR(SERVER_FAILURE);
761 ldb_transaction_cancel(dns->samdb);
768 system_session(dns->task->lp_ctx));
771 TALLOC_FREE(tmp_ctx);
776 static WERROR dns_update_allowed(struct dns_server *dns,
777 const struct dns_request_state *state,
778 struct dns_server_tkey **tkey)
780 if (lpcfg_allow_dns_updates(dns->task->lp_ctx) == DNS_UPDATE_ON) {
781 DEBUG(2, ("All updates allowed.\n"));
785 if (lpcfg_allow_dns_updates(dns->task->lp_ctx) == DNS_UPDATE_OFF) {
786 DEBUG(2, ("Updates disabled.\n"));
787 return DNS_ERR(REFUSED);
790 if (state->authenticated == false ) {
791 DEBUG(2, ("Update not allowed for unsigned packet.\n"));
792 return DNS_ERR(REFUSED);
795 *tkey = dns_find_tkey(dns->tkeys, state->key_name);
797 DEBUG(0, ("Authenticated, but key not found. Something is wrong.\n"));
798 return DNS_ERR(REFUSED);
805 WERROR dns_server_process_update(struct dns_server *dns,
806 const struct dns_request_state *state,
808 const struct dns_name_packet *in,
809 struct dns_res_rec **prereqs, uint16_t *prereq_count,
810 struct dns_res_rec **updates, uint16_t *update_count,
811 struct dns_res_rec **additional, uint16_t *arcount)
813 struct dns_name_question *zone;
814 const struct dns_server_zone *z;
815 size_t host_part_len = 0;
816 WERROR werror = DNS_ERR(NOT_IMPLEMENTED);
817 struct dns_server_tkey *tkey = NULL;
819 if (in->qdcount != 1) {
820 return DNS_ERR(FORMAT_ERROR);
823 zone = &in->questions[0];
825 if (zone->question_class != DNS_QCLASS_IN &&
826 zone->question_class != DNS_QCLASS_ANY) {
827 return DNS_ERR(NOT_IMPLEMENTED);
830 if (zone->question_type != DNS_QTYPE_SOA) {
831 return DNS_ERR(FORMAT_ERROR);
834 DEBUG(2, ("Got a dns update request.\n"));
836 for (z = dns->zones; z != NULL; z = z->next) {
839 match = dns_name_match(z->name, zone->name, &host_part_len);
846 DEBUG(1, ("We're not authoritative for this zone\n"));
847 return DNS_ERR(NOTAUTH);
850 if (host_part_len != 0) {
851 /* TODO: We need to delegate this one */
852 DEBUG(1, ("Would have to delegate zone '%s'.\n", zone->name));
853 return DNS_ERR(NOT_IMPLEMENTED);
856 *prereq_count = in->ancount;
857 *prereqs = in->answers;
858 werror = check_prerequisites(dns, mem_ctx, in->questions, *prereqs,
860 W_ERROR_NOT_OK_RETURN(werror);
862 werror = dns_update_allowed(dns, state, &tkey);
863 if (!W_ERROR_IS_OK(werror)) {
867 *update_count = in->nscount;
868 *updates = in->nsrecs;
869 werror = update_prescan(in->questions, *updates, *update_count);
870 DBG_DEBUG("update_prescan(): %s\n", win_errstr(werror));
871 W_ERROR_NOT_OK_RETURN(werror);
873 werror = handle_updates(dns, mem_ctx, in->questions, *prereqs,
874 *prereq_count, *updates, *update_count, tkey);
875 DBG_DEBUG("handle_updates(): %s\n", win_errstr(werror));
876 W_ERROR_NOT_OK_RETURN(werror);