2 Unix SMB/CIFS implementation.
4 DNS server handler for queries
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 "smbd/service_task.h"
24 #include "libcli/util/werror.h"
25 #include "librpc/ndr/libndr.h"
26 #include "librpc/gen_ndr/ndr_dns.h"
27 #include "librpc/gen_ndr/ndr_dnsp.h"
29 #include "param/param.h"
30 #include "dsdb/samdb/samdb.h"
31 #include "dsdb/common/util.h"
32 #include "dns_server/dns_server.h"
33 #include "libcli/dns/libdns.h"
34 #include "lib/util/util_net.h"
35 #include "lib/util/tevent_werror.h"
36 #include "auth/auth.h"
37 #include "auth/credentials/credentials.h"
38 #include "auth/gensec/gensec.h"
41 #define DBGC_CLASS DBGC_DNS
43 static WERROR
create_response_rr(const char *name
,
44 const struct dnsp_DnssrvRpcRecord
*rec
,
45 struct dns_res_rec
**answers
, uint16_t *ancount
)
47 struct dns_res_rec
*ans
= *answers
;
48 uint16_t ai
= *ancount
;
56 ans
[ai
].rdata
.cname_record
= talloc_strdup(ans
, rec
->data
.cname
);
57 W_ERROR_HAVE_NO_MEMORY(ans
[ai
].rdata
.cname_record
);
60 ans
[ai
].rdata
.ipv4_record
= talloc_strdup(ans
, rec
->data
.ipv4
);
61 W_ERROR_HAVE_NO_MEMORY(ans
[ai
].rdata
.ipv4_record
);
64 ans
[ai
].rdata
.ipv6_record
= talloc_strdup(ans
, rec
->data
.ipv6
);
65 W_ERROR_HAVE_NO_MEMORY(ans
[ai
].rdata
.ipv6_record
);
68 ans
[ai
].rdata
.ns_record
= talloc_strdup(ans
, rec
->data
.ns
);
69 W_ERROR_HAVE_NO_MEMORY(ans
[ai
].rdata
.ns_record
);
72 ans
[ai
].rdata
.srv_record
.priority
= rec
->data
.srv
.wPriority
;
73 ans
[ai
].rdata
.srv_record
.weight
= rec
->data
.srv
.wWeight
;
74 ans
[ai
].rdata
.srv_record
.port
= rec
->data
.srv
.wPort
;
75 ans
[ai
].rdata
.srv_record
.target
= talloc_strdup(
76 ans
, rec
->data
.srv
.nameTarget
);
77 W_ERROR_HAVE_NO_MEMORY(ans
[ai
].rdata
.srv_record
.target
);
80 ans
[ai
].rdata
.soa_record
.mname
= talloc_strdup(
81 ans
, rec
->data
.soa
.mname
);
82 W_ERROR_HAVE_NO_MEMORY(ans
[ai
].rdata
.soa_record
.mname
);
83 ans
[ai
].rdata
.soa_record
.rname
= talloc_strdup(
84 ans
, rec
->data
.soa
.rname
);
85 W_ERROR_HAVE_NO_MEMORY(ans
[ai
].rdata
.soa_record
.rname
);
86 ans
[ai
].rdata
.soa_record
.serial
= rec
->data
.soa
.serial
;
87 ans
[ai
].rdata
.soa_record
.refresh
= rec
->data
.soa
.refresh
;
88 ans
[ai
].rdata
.soa_record
.retry
= rec
->data
.soa
.retry
;
89 ans
[ai
].rdata
.soa_record
.expire
= rec
->data
.soa
.expire
;
90 ans
[ai
].rdata
.soa_record
.minimum
= rec
->data
.soa
.minimum
;
93 ans
[ai
].rdata
.ptr_record
= talloc_strdup(ans
, rec
->data
.ptr
);
94 W_ERROR_HAVE_NO_MEMORY(ans
[ai
].rdata
.ptr_record
);
97 ans
[ai
].rdata
.mx_record
.preference
= rec
->data
.mx
.wPriority
;
98 ans
[ai
].rdata
.mx_record
.exchange
= talloc_strdup(
99 ans
, rec
->data
.mx
.nameTarget
);
100 if (ans
[ai
].rdata
.mx_record
.exchange
== NULL
) {
105 tmp
= talloc_asprintf(ans
, "\"%s\"", rec
->data
.txt
.str
[0]);
106 W_ERROR_HAVE_NO_MEMORY(tmp
);
107 for (i
=1; i
<rec
->data
.txt
.count
; i
++) {
108 tmp
= talloc_asprintf_append_buffer(
109 tmp
, " \"%s\"", rec
->data
.txt
.str
[i
]);
110 W_ERROR_HAVE_NO_MEMORY(tmp
);
112 ans
[ai
].rdata
.txt_record
.txt
= tmp
;
115 DEBUG(0, ("Got unhandled type %u query.\n", rec
->wType
));
116 return DNS_ERR(NOT_IMPLEMENTED
);
119 ans
[ai
].name
= talloc_strdup(ans
, name
);
120 W_ERROR_HAVE_NO_MEMORY(ans
[ai
].name
);
121 ans
[ai
].rr_type
= rec
->wType
;
122 ans
[ai
].rr_class
= DNS_QCLASS_IN
;
123 ans
[ai
].ttl
= rec
->dwTtlSeconds
;
124 ans
[ai
].length
= UINT16_MAX
;
133 struct ask_forwarder_state
{
134 struct tevent_context
*ev
;
136 struct dns_name_packet in_packet
;
139 static void ask_forwarder_done(struct tevent_req
*subreq
);
141 static struct tevent_req
*ask_forwarder_send(
142 struct dns_server
*dns
,
143 TALLOC_CTX
*mem_ctx
, struct tevent_context
*ev
,
144 const char *forwarder
, struct dns_name_question
*question
)
146 struct tevent_req
*req
, *subreq
;
147 struct ask_forwarder_state
*state
;
148 struct dns_res_rec
*options
;
149 struct dns_name_packet out_packet
= { 0, };
151 enum ndr_err_code ndr_err
;
154 req
= tevent_req_create(mem_ctx
, &state
, struct ask_forwarder_state
);
159 generate_random_buffer((uint8_t *)&state
->id
, sizeof(state
->id
));
161 if (!is_ipaddress(forwarder
)) {
162 DEBUG(0, ("Invalid 'dns forwarder' setting '%s', needs to be "
163 "an IP address\n", forwarder
));
164 tevent_req_werror(req
, DNS_ERR(NAME_ERROR
));
165 return tevent_req_post(req
, ev
);
168 out_packet
.id
= state
->id
;
169 out_packet
.operation
|= DNS_OPCODE_QUERY
| DNS_FLAG_RECURSION_DESIRED
;
170 out_packet
.qdcount
= 1;
171 out_packet
.questions
= question
;
173 werr
= dns_generate_options(dns
, state
, &options
);
174 if (!W_ERROR_IS_OK(werr
)) {
175 tevent_req_werror(req
, werr
);
176 return tevent_req_post(req
, ev
);
179 out_packet
.arcount
= 1;
180 out_packet
.additional
= options
;
182 ndr_err
= ndr_push_struct_blob(
183 &out_blob
, state
, &out_packet
,
184 (ndr_push_flags_fn_t
)ndr_push_dns_name_packet
);
185 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
186 tevent_req_werror(req
, DNS_ERR(SERVER_FAILURE
));
187 return tevent_req_post(req
, ev
);
189 subreq
= dns_udp_request_send(state
, ev
, forwarder
, out_blob
.data
,
191 if (tevent_req_nomem(subreq
, req
)) {
192 return tevent_req_post(req
, ev
);
194 tevent_req_set_callback(subreq
, ask_forwarder_done
, req
);
198 static void ask_forwarder_done(struct tevent_req
*subreq
)
200 struct tevent_req
*req
= tevent_req_callback_data(
201 subreq
, struct tevent_req
);
202 struct ask_forwarder_state
*state
= tevent_req_data(
203 req
, struct ask_forwarder_state
);
205 enum ndr_err_code ndr_err
;
208 ret
= dns_udp_request_recv(subreq
, state
,
209 &in_blob
.data
, &in_blob
.length
);
213 tevent_req_werror(req
, unix_to_werror(ret
));
217 ndr_err
= ndr_pull_struct_blob(
218 &in_blob
, state
, &state
->in_packet
,
219 (ndr_pull_flags_fn_t
)ndr_pull_dns_name_packet
);
220 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
221 tevent_req_werror(req
, DNS_ERR(SERVER_FAILURE
));
224 if (state
->in_packet
.id
!= state
->id
) {
225 tevent_req_werror(req
, DNS_ERR(NAME_ERROR
));
228 tevent_req_done(req
);
231 static WERROR
ask_forwarder_recv(
232 struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
,
233 struct dns_res_rec
**answers
, uint16_t *ancount
,
234 struct dns_res_rec
**nsrecs
, uint16_t *nscount
,
235 struct dns_res_rec
**additional
, uint16_t *arcount
)
237 struct ask_forwarder_state
*state
= tevent_req_data(
238 req
, struct ask_forwarder_state
);
239 struct dns_name_packet
*in_packet
= &state
->in_packet
;
242 if (tevent_req_is_werror(req
, &err
)) {
246 *ancount
= in_packet
->ancount
;
247 *answers
= talloc_move(mem_ctx
, &in_packet
->answers
);
249 *nscount
= in_packet
->nscount
;
250 *nsrecs
= talloc_move(mem_ctx
, &in_packet
->nsrecs
);
252 *arcount
= in_packet
->arcount
;
253 *additional
= talloc_move(mem_ctx
, &in_packet
->additional
);
258 static WERROR
add_zone_authority_record(struct dns_server
*dns
,
260 const struct dns_name_question
*question
,
261 struct dns_res_rec
**nsrecs
, uint16_t *nscount
)
263 const char *zone
= NULL
;
264 struct dnsp_DnssrvRpcRecord
*recs
;
265 struct dns_res_rec
*ns
= *nsrecs
;
266 uint16_t rec_count
, ni
= *nscount
;
267 struct ldb_dn
*dn
= NULL
;
271 zone
= dns_get_authoritative_zone(dns
, question
->name
);
272 DEBUG(10, ("Creating zone authority record for '%s'\n", zone
));
274 werror
= dns_name2dn(dns
, mem_ctx
, zone
, &dn
);
275 if (!W_ERROR_IS_OK(werror
)) {
279 werror
= dns_lookup_records(dns
, mem_ctx
, dn
, &recs
, &rec_count
);
280 if (!W_ERROR_IS_OK(werror
)) {
284 ns
= talloc_realloc(mem_ctx
, ns
, struct dns_res_rec
, rec_count
+ ni
);
288 for (ri
= 0; ri
< rec_count
; ri
++) {
289 if (recs
[ri
].wType
== DNS_TYPE_SOA
) {
290 werror
= create_response_rr(zone
, &recs
[ri
], &ns
, &ni
);
291 if (!W_ERROR_IS_OK(werror
)) {
304 static WERROR
handle_question(struct dns_server
*dns
,
306 const struct dns_name_question
*question
,
307 struct dns_res_rec
**answers
, uint16_t *ancount
,
308 struct dns_res_rec
**nsrecs
, uint16_t *nscount
)
310 struct dns_res_rec
*ans
= *answers
;
311 struct dns_res_rec
*ns
= *nsrecs
;
312 WERROR werror
, werror_return
;
314 struct dnsp_DnssrvRpcRecord
*recs
;
315 uint16_t rec_count
, ai
= *ancount
, ni
= *nscount
;
316 struct ldb_dn
*dn
= NULL
;
318 werror
= dns_name2dn(dns
, mem_ctx
, question
->name
, &dn
);
319 if (!W_ERROR_IS_OK(werror
)) {
323 werror
= dns_lookup_records(dns
, mem_ctx
, dn
, &recs
, &rec_count
);
324 if (!W_ERROR_IS_OK(werror
)) {
325 werror_return
= werror
;
329 ans
= talloc_realloc(mem_ctx
, ans
, struct dns_res_rec
, rec_count
+ ai
);
334 /* Set up for an NXDOMAIN reply if no match is found */
335 werror_return
= DNS_ERR(NAME_ERROR
);
337 for (ri
= 0; ri
< rec_count
; ri
++) {
338 if ((recs
[ri
].wType
== DNS_TYPE_CNAME
) &&
339 ((question
->question_type
== DNS_QTYPE_A
) ||
340 (question
->question_type
== DNS_QTYPE_AAAA
))) {
341 struct dns_name_question
*new_q
=
342 talloc(mem_ctx
, struct dns_name_question
);
348 /* We reply with one more record, so grow the array */
349 ans
= talloc_realloc(mem_ctx
, ans
, struct dns_res_rec
,
356 /* First put in the CNAME record */
357 werror
= create_response_rr(question
->name
, &recs
[ri
], &ans
, &ai
);
358 if (!W_ERROR_IS_OK(werror
)) {
363 /* And then look up the name it points at.. */
365 /* First build up the new question */
366 new_q
->question_type
= question
->question_type
;
367 new_q
->question_class
= question
->question_class
;
368 new_q
->name
= talloc_strdup(new_q
, recs
[ri
].data
.cname
);
369 if (new_q
->name
== NULL
) {
373 /* and then call the lookup again */
374 werror
= handle_question(dns
, mem_ctx
, new_q
, &ans
, &ai
, &ns
, &ni
);
375 if (!W_ERROR_IS_OK(werror
)) {
378 werror_return
= WERR_OK
;
383 if ((question
->question_type
!= DNS_QTYPE_ALL
) &&
384 (recs
[ri
].wType
!= (enum dns_record_type
) question
->question_type
)) {
385 werror_return
= WERR_OK
;
388 werror
= create_response_rr(question
->name
, &recs
[ri
], &ans
, &ai
);
389 if (!W_ERROR_IS_OK(werror
)) {
392 werror_return
= WERR_OK
;
396 /* Always add an authority record to replies we should know about */
397 add_zone_authority_record(dns
, mem_ctx
, question
, &ns
, &ni
);
404 return werror_return
;
407 static NTSTATUS
create_tkey(struct dns_server
*dns
,
409 const char* algorithm
,
410 struct dns_server_tkey
**tkey
)
413 struct dns_server_tkey_store
*store
= dns
->tkeys
;
414 struct dns_server_tkey
*k
= talloc_zero(store
, struct dns_server_tkey
);
417 return NT_STATUS_NO_MEMORY
;
420 k
->name
= talloc_strdup(k
, name
);
422 if (k
->name
== NULL
) {
423 return NT_STATUS_NO_MEMORY
;
426 k
->algorithm
= talloc_strdup(k
, algorithm
);
427 if (k
->algorithm
== NULL
) {
428 return NT_STATUS_NO_MEMORY
;
431 status
= samba_server_gensec_start(k
,
432 dns
->task
->event_ctx
,
435 dns
->server_credentials
,
438 if (!NT_STATUS_IS_OK(status
)) {
439 DEBUG(1, ("Failed to start GENSEC server code: %s\n", nt_errstr(status
)));
444 gensec_want_feature(k
->gensec
, GENSEC_FEATURE_SIGN
);
446 status
= gensec_start_mech_by_oid(k
->gensec
, GENSEC_OID_SPNEGO
);
448 if (!NT_STATUS_IS_OK(status
)) {
449 DEBUG(1, ("Failed to start GENSEC server code: %s\n",
455 if (store
->tkeys
[store
->next_idx
] != NULL
) {
456 TALLOC_FREE(store
->tkeys
[store
->next_idx
]);
459 store
->tkeys
[store
->next_idx
] = k
;
461 store
->next_idx
%= store
->size
;
467 static NTSTATUS
accept_gss_ticket(TALLOC_CTX
*mem_ctx
,
468 struct dns_server
*dns
,
469 struct dns_server_tkey
*tkey
,
470 const DATA_BLOB
*key
,
472 uint16_t *dns_auth_error
)
476 status
= gensec_update_ev(tkey
->gensec
, mem_ctx
, dns
->task
->event_ctx
,
479 if (NT_STATUS_EQUAL(NT_STATUS_MORE_PROCESSING_REQUIRED
, status
)) {
480 *dns_auth_error
= DNS_RCODE_OK
;
484 if (NT_STATUS_IS_OK(status
)) {
486 status
= gensec_session_info(tkey
->gensec
, tkey
, &tkey
->session_info
);
487 if (!NT_STATUS_IS_OK(status
)) {
488 *dns_auth_error
= DNS_RCODE_BADKEY
;
491 *dns_auth_error
= DNS_RCODE_OK
;
497 static WERROR
handle_tkey(struct dns_server
*dns
,
499 const struct dns_name_packet
*in
,
500 struct dns_request_state
*state
,
501 struct dns_res_rec
**answers
,
504 struct dns_res_rec
*in_tkey
= NULL
;
505 struct dns_res_rec
*ret_tkey
;
508 for (i
= 0; i
< in
->arcount
; i
++) {
509 if (in
->additional
[i
].rr_type
== DNS_QTYPE_TKEY
) {
510 in_tkey
= &in
->additional
[i
];
515 /* If this is a TKEY query, it should have a TKEY RR.
516 * Behaviour is not really specified in RFC 2930 or RFC 3645, but
517 * FORMAT_ERROR seems to be what BIND uses .*/
518 if (in_tkey
== NULL
) {
519 return DNS_ERR(FORMAT_ERROR
);
522 ret_tkey
= talloc_zero(mem_ctx
, struct dns_res_rec
);
523 if (ret_tkey
== NULL
) {
527 ret_tkey
->name
= talloc_strdup(ret_tkey
, in_tkey
->name
);
528 if (ret_tkey
->name
== NULL
) {
532 ret_tkey
->rr_type
= DNS_QTYPE_TKEY
;
533 ret_tkey
->rr_class
= DNS_QCLASS_ANY
;
534 ret_tkey
->length
= UINT16_MAX
;
536 ret_tkey
->rdata
.tkey_record
.algorithm
= talloc_strdup(ret_tkey
,
537 in_tkey
->rdata
.tkey_record
.algorithm
);
538 if (ret_tkey
->rdata
.tkey_record
.algorithm
== NULL
) {
542 ret_tkey
->rdata
.tkey_record
.inception
= in_tkey
->rdata
.tkey_record
.inception
;
543 ret_tkey
->rdata
.tkey_record
.expiration
= in_tkey
->rdata
.tkey_record
.expiration
;
544 ret_tkey
->rdata
.tkey_record
.mode
= in_tkey
->rdata
.tkey_record
.mode
;
546 switch (in_tkey
->rdata
.tkey_record
.mode
) {
547 case DNS_TKEY_MODE_DH
:
548 /* FIXME: According to RFC 2930, we MUST support this, but we don't.
549 * Still, claim it's a bad key instead of a bad mode */
550 ret_tkey
->rdata
.tkey_record
.error
= DNS_RCODE_BADKEY
;
552 case DNS_TKEY_MODE_GSSAPI
: {
554 struct dns_server_tkey
*tkey
;
558 tkey
= dns_find_tkey(dns
->tkeys
, in
->questions
[0].name
);
559 if (tkey
!= NULL
&& tkey
->complete
) {
560 /* TODO: check if the key is still valid */
561 DEBUG(1, ("Rejecting tkey negotiation for already established key\n"));
562 ret_tkey
->rdata
.tkey_record
.error
= DNS_RCODE_BADNAME
;
567 status
= create_tkey(dns
, in
->questions
[0].name
,
568 in_tkey
->rdata
.tkey_record
.algorithm
,
570 if (!NT_STATUS_IS_OK(status
)) {
571 ret_tkey
->rdata
.tkey_record
.error
= DNS_RCODE_BADKEY
;
572 return ntstatus_to_werror(status
);
576 key
.data
= in_tkey
->rdata
.tkey_record
.key_data
;
577 key
.length
= in_tkey
->rdata
.tkey_record
.key_size
;
579 status
= accept_gss_ticket(ret_tkey
, dns
, tkey
, &key
, &reply
,
580 &ret_tkey
->rdata
.tkey_record
.error
);
581 if (NT_STATUS_EQUAL(status
, NT_STATUS_MORE_PROCESSING_REQUIRED
)) {
582 DEBUG(1, ("More processing required\n"));
583 ret_tkey
->rdata
.tkey_record
.error
= DNS_RCODE_BADKEY
;
584 } else if (NT_STATUS_IS_OK(status
)) {
585 DEBUG(1, ("Tkey handshake completed\n"));
586 ret_tkey
->rdata
.tkey_record
.key_size
= reply
.length
;
587 ret_tkey
->rdata
.tkey_record
.key_data
= talloc_memdup(ret_tkey
,
591 state
->key_name
= talloc_strdup(state
->mem_ctx
, tkey
->name
);
592 if (state
->key_name
== NULL
) {
596 DEBUG(1, ("GSS key negotiation returned %s\n", nt_errstr(status
)));
597 ret_tkey
->rdata
.tkey_record
.error
= DNS_RCODE_BADKEY
;
602 case DNS_TKEY_MODE_DELETE
:
603 /* TODO: implement me */
604 DEBUG(1, ("Should delete tkey here\n"));
605 ret_tkey
->rdata
.tkey_record
.error
= DNS_RCODE_OK
;
607 case DNS_TKEY_MODE_NULL
:
608 case DNS_TKEY_MODE_SERVER
:
609 case DNS_TKEY_MODE_CLIENT
:
610 case DNS_TKEY_MODE_LAST
:
611 /* We don't have to implement these, return a mode error */
612 ret_tkey
->rdata
.tkey_record
.error
= DNS_RCODE_BADMODE
;
615 DEBUG(1, ("Unsupported TKEY mode %d\n",
616 in_tkey
->rdata
.tkey_record
.mode
));
625 struct dns_server_process_query_state
{
626 struct dns_res_rec
*answers
;
628 struct dns_res_rec
*nsrecs
;
630 struct dns_res_rec
*additional
;
634 static void dns_server_process_query_got_response(struct tevent_req
*subreq
);
636 struct tevent_req
*dns_server_process_query_send(
637 TALLOC_CTX
*mem_ctx
, struct tevent_context
*ev
,
638 struct dns_server
*dns
, struct dns_request_state
*req_state
,
639 const struct dns_name_packet
*in
)
641 struct tevent_req
*req
, *subreq
;
642 struct dns_server_process_query_state
*state
;
644 req
= tevent_req_create(mem_ctx
, &state
,
645 struct dns_server_process_query_state
);
649 if (in
->qdcount
!= 1) {
650 tevent_req_werror(req
, DNS_ERR(FORMAT_ERROR
));
651 return tevent_req_post(req
, ev
);
654 /* Windows returns NOT_IMPLEMENTED on this as well */
655 if (in
->questions
[0].question_class
== DNS_QCLASS_NONE
) {
656 tevent_req_werror(req
, DNS_ERR(NOT_IMPLEMENTED
));
657 return tevent_req_post(req
, ev
);
660 if (in
->questions
[0].question_type
== DNS_QTYPE_TKEY
) {
663 err
= handle_tkey(dns
, state
, in
, req_state
,
664 &state
->answers
, &state
->ancount
);
665 if (tevent_req_werror(req
, err
)) {
666 return tevent_req_post(req
, ev
);
668 tevent_req_done(req
);
669 return tevent_req_post(req
, ev
);
672 if (dns_authorative_for_zone(dns
, in
->questions
[0].name
)) {
675 req_state
->flags
|= DNS_FLAG_AUTHORITATIVE
;
676 err
= handle_question(dns
, state
, &in
->questions
[0],
677 &state
->answers
, &state
->ancount
,
678 &state
->nsrecs
, &state
->nscount
);
680 if (W_ERROR_EQUAL(err
, DNS_ERR(NAME_ERROR
))) {
684 if (tevent_req_werror(req
, err
)) {
685 return tevent_req_post(req
, ev
);
688 tevent_req_done(req
);
689 return tevent_req_post(req
, ev
);
692 if ((req_state
->flags
& DNS_FLAG_RECURSION_DESIRED
) &&
693 (req_state
->flags
& DNS_FLAG_RECURSION_AVAIL
)) {
694 DEBUG(2, ("Not authoritative for '%s', forwarding\n",
695 in
->questions
[0].name
));
697 subreq
= ask_forwarder_send(
699 state
, ev
, lpcfg_dns_forwarder(dns
->task
->lp_ctx
),
701 if (tevent_req_nomem(subreq
, req
)) {
702 return tevent_req_post(req
, ev
);
704 tevent_req_set_callback(
705 subreq
, dns_server_process_query_got_response
, req
);
709 tevent_req_werror(req
, DNS_ERR(NAME_ERROR
));
710 return tevent_req_post(req
, ev
);
713 static void dns_server_process_query_got_response(struct tevent_req
*subreq
)
715 struct tevent_req
*req
= tevent_req_callback_data(
716 subreq
, struct tevent_req
);
717 struct dns_server_process_query_state
*state
= tevent_req_data(
718 req
, struct dns_server_process_query_state
);
721 err
= ask_forwarder_recv(subreq
, state
,
722 &state
->answers
, &state
->ancount
,
723 &state
->nsrecs
, &state
->nscount
,
724 &state
->additional
, &state
->arcount
);
726 if (tevent_req_werror(req
, err
)) {
729 tevent_req_done(req
);
732 WERROR
dns_server_process_query_recv(
733 struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
,
734 struct dns_res_rec
**answers
, uint16_t *ancount
,
735 struct dns_res_rec
**nsrecs
, uint16_t *nscount
,
736 struct dns_res_rec
**additional
, uint16_t *arcount
)
738 struct dns_server_process_query_state
*state
= tevent_req_data(
739 req
, struct dns_server_process_query_state
);
740 WERROR err
= WERR_OK
;
742 if (tevent_req_is_werror(req
, &err
)) {
744 if ((!W_ERROR_EQUAL(err
, DNS_ERR(NAME_ERROR
))) &&
745 (!W_ERROR_EQUAL(err
, WERR_DNS_ERROR_NAME_DOES_NOT_EXIST
))) {
749 *answers
= talloc_move(mem_ctx
, &state
->answers
);
750 *ancount
= state
->ancount
;
751 *nsrecs
= talloc_move(mem_ctx
, &state
->nsrecs
);
752 *nscount
= state
->nscount
;
753 *additional
= talloc_move(mem_ctx
, &state
->additional
);
754 *arcount
= state
->arcount
;