1238106Sdes/*
2238106Sdes * iterator/iter_delegpt.c - delegation point with NS and address information.
3238106Sdes *
4238106Sdes * Copyright (c) 2007, NLnet Labs. All rights reserved.
5238106Sdes *
6238106Sdes * This software is open source.
7238106Sdes *
8238106Sdes * Redistribution and use in source and binary forms, with or without
9238106Sdes * modification, are permitted provided that the following conditions
10238106Sdes * are met:
11238106Sdes *
12238106Sdes * Redistributions of source code must retain the above copyright notice,
13238106Sdes * this list of conditions and the following disclaimer.
14238106Sdes *
15238106Sdes * Redistributions in binary form must reproduce the above copyright notice,
16238106Sdes * this list of conditions and the following disclaimer in the documentation
17238106Sdes * and/or other materials provided with the distribution.
18238106Sdes *
19238106Sdes * Neither the name of the NLNET LABS nor the names of its contributors may
20238106Sdes * be used to endorse or promote products derived from this software without
21238106Sdes * specific prior written permission.
22238106Sdes *
23238106Sdes * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
24238106Sdes * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
25238106Sdes * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
26238106Sdes * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE
27238106Sdes * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
28238106Sdes * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
29238106Sdes * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
30238106Sdes * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
31238106Sdes * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
32238106Sdes * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
33238106Sdes * POSSIBILITY OF SUCH DAMAGE.
34238106Sdes */
35238106Sdes
36238106Sdes/**
37238106Sdes * \file
38238106Sdes *
39238106Sdes * This file implements the Delegation Point. It contains a list of name servers
40238106Sdes * and their addresses if known.
41238106Sdes */
42238106Sdes#include "config.h"
43238106Sdes#include "iterator/iter_delegpt.h"
44238106Sdes#include "services/cache/dns.h"
45238106Sdes#include "util/regional.h"
46238106Sdes#include "util/data/dname.h"
47238106Sdes#include "util/data/packed_rrset.h"
48238106Sdes#include "util/data/msgreply.h"
49238106Sdes#include "util/net_help.h"
50238106Sdes
51238106Sdesstruct delegpt*
52238106Sdesdelegpt_create(struct regional* region)
53238106Sdes{
54238106Sdes	struct delegpt* dp=(struct delegpt*)regional_alloc(
55238106Sdes		region, sizeof(*dp));
56238106Sdes	if(!dp)
57238106Sdes		return NULL;
58238106Sdes	memset(dp, 0, sizeof(*dp));
59238106Sdes	return dp;
60238106Sdes}
61238106Sdes
62238106Sdesstruct delegpt* delegpt_copy(struct delegpt* dp, struct regional* region)
63238106Sdes{
64238106Sdes	struct delegpt* copy = delegpt_create(region);
65238106Sdes	struct delegpt_ns* ns;
66238106Sdes	struct delegpt_addr* a;
67238106Sdes	if(!copy)
68238106Sdes		return NULL;
69238106Sdes	if(!delegpt_set_name(copy, region, dp->name))
70238106Sdes		return NULL;
71238106Sdes	copy->bogus = dp->bogus;
72238106Sdes	copy->has_parent_side_NS = dp->has_parent_side_NS;
73238106Sdes	for(ns = dp->nslist; ns; ns = ns->next) {
74238106Sdes		if(!delegpt_add_ns(copy, region, ns->name, (int)ns->lame))
75238106Sdes			return NULL;
76238106Sdes		copy->nslist->resolved = ns->resolved;
77238106Sdes		copy->nslist->got4 = ns->got4;
78238106Sdes		copy->nslist->got6 = ns->got6;
79238106Sdes		copy->nslist->done_pside4 = ns->done_pside4;
80238106Sdes		copy->nslist->done_pside6 = ns->done_pside6;
81238106Sdes	}
82238106Sdes	for(a = dp->target_list; a; a = a->next_target) {
83238106Sdes		if(!delegpt_add_addr(copy, region, &a->addr, a->addrlen,
84238106Sdes			a->bogus, a->lame))
85238106Sdes			return NULL;
86238106Sdes	}
87238106Sdes	return copy;
88238106Sdes}
89238106Sdes
90238106Sdesint
91238106Sdesdelegpt_set_name(struct delegpt* dp, struct regional* region, uint8_t* name)
92238106Sdes{
93238106Sdes	log_assert(!dp->dp_type_mlc);
94238106Sdes	dp->namelabs = dname_count_size_labels(name, &dp->namelen);
95238106Sdes	dp->name = regional_alloc_init(region, name, dp->namelen);
96238106Sdes	return dp->name != 0;
97238106Sdes}
98238106Sdes
99238106Sdesint
100238106Sdesdelegpt_add_ns(struct delegpt* dp, struct regional* region, uint8_t* name,
101238106Sdes	int lame)
102238106Sdes{
103238106Sdes	struct delegpt_ns* ns;
104238106Sdes	size_t len;
105238106Sdes	(void)dname_count_size_labels(name, &len);
106238106Sdes	log_assert(!dp->dp_type_mlc);
107238106Sdes	/* slow check for duplicates to avoid counting failures when
108238106Sdes	 * adding the same server as a dependency twice */
109238106Sdes	if(delegpt_find_ns(dp, name, len))
110238106Sdes		return 1;
111238106Sdes	ns = (struct delegpt_ns*)regional_alloc(region,
112238106Sdes		sizeof(struct delegpt_ns));
113238106Sdes	if(!ns)
114238106Sdes		return 0;
115238106Sdes	ns->next = dp->nslist;
116238106Sdes	ns->namelen = len;
117238106Sdes	dp->nslist = ns;
118238106Sdes	ns->name = regional_alloc_init(region, name, ns->namelen);
119238106Sdes	ns->resolved = 0;
120238106Sdes	ns->got4 = 0;
121238106Sdes	ns->got6 = 0;
122238106Sdes	ns->lame = (uint8_t)lame;
123238106Sdes	ns->done_pside4 = 0;
124238106Sdes	ns->done_pside6 = 0;
125238106Sdes	return ns->name != 0;
126238106Sdes}
127238106Sdes
128238106Sdesstruct delegpt_ns*
129238106Sdesdelegpt_find_ns(struct delegpt* dp, uint8_t* name, size_t namelen)
130238106Sdes{
131238106Sdes	struct delegpt_ns* p = dp->nslist;
132238106Sdes	while(p) {
133238106Sdes		if(namelen == p->namelen &&
134238106Sdes			query_dname_compare(name, p->name) == 0) {
135238106Sdes			return p;
136238106Sdes		}
137238106Sdes		p = p->next;
138238106Sdes	}
139238106Sdes	return NULL;
140238106Sdes}
141238106Sdes
142238106Sdesstruct delegpt_addr*
143238106Sdesdelegpt_find_addr(struct delegpt* dp, struct sockaddr_storage* addr,
144238106Sdes	socklen_t addrlen)
145238106Sdes{
146238106Sdes	struct delegpt_addr* p = dp->target_list;
147238106Sdes	while(p) {
148238106Sdes		if(sockaddr_cmp_addr(addr, addrlen, &p->addr, p->addrlen)==0) {
149238106Sdes			return p;
150238106Sdes		}
151238106Sdes		p = p->next_target;
152238106Sdes	}
153238106Sdes	return NULL;
154238106Sdes}
155238106Sdes
156238106Sdesint
157238106Sdesdelegpt_add_target(struct delegpt* dp, struct regional* region,
158238106Sdes	uint8_t* name, size_t namelen, struct sockaddr_storage* addr,
159238106Sdes	socklen_t addrlen, int bogus, int lame)
160238106Sdes{
161238106Sdes	struct delegpt_ns* ns = delegpt_find_ns(dp, name, namelen);
162238106Sdes	log_assert(!dp->dp_type_mlc);
163238106Sdes	if(!ns) {
164238106Sdes		/* ignore it */
165238106Sdes		return 1;
166238106Sdes	}
167238106Sdes	if(!lame) {
168238106Sdes		if(addr_is_ip6(addr, addrlen))
169238106Sdes			ns->got6 = 1;
170238106Sdes		else	ns->got4 = 1;
171238106Sdes		if(ns->got4 && ns->got6)
172238106Sdes			ns->resolved = 1;
173238106Sdes	}
174238106Sdes	return delegpt_add_addr(dp, region, addr, addrlen, bogus, lame);
175238106Sdes}
176238106Sdes
177238106Sdesint
178238106Sdesdelegpt_add_addr(struct delegpt* dp, struct regional* region,
179238106Sdes	struct sockaddr_storage* addr, socklen_t addrlen, int bogus,
180238106Sdes	int lame)
181238106Sdes{
182238106Sdes	struct delegpt_addr* a;
183238106Sdes	log_assert(!dp->dp_type_mlc);
184238106Sdes	/* check for duplicates */
185238106Sdes	if((a = delegpt_find_addr(dp, addr, addrlen))) {
186238106Sdes		if(bogus)
187238106Sdes			a->bogus = bogus;
188238106Sdes		if(!lame)
189238106Sdes			a->lame = 0;
190238106Sdes		return 1;
191238106Sdes	}
192238106Sdes
193238106Sdes	a = (struct delegpt_addr*)regional_alloc(region,
194238106Sdes		sizeof(struct delegpt_addr));
195238106Sdes	if(!a)
196238106Sdes		return 0;
197238106Sdes	a->next_target = dp->target_list;
198238106Sdes	dp->target_list = a;
199238106Sdes	a->next_result = 0;
200238106Sdes	a->next_usable = dp->usable_list;
201238106Sdes	dp->usable_list = a;
202238106Sdes	memcpy(&a->addr, addr, addrlen);
203238106Sdes	a->addrlen = addrlen;
204238106Sdes	a->attempts = 0;
205238106Sdes	a->bogus = bogus;
206238106Sdes	a->lame = lame;
207238106Sdes	return 1;
208238106Sdes}
209238106Sdes
210238106Sdesvoid
211238106Sdesdelegpt_count_ns(struct delegpt* dp, size_t* numns, size_t* missing)
212238106Sdes{
213238106Sdes	struct delegpt_ns* ns;
214238106Sdes	*numns = 0;
215238106Sdes	*missing = 0;
216238106Sdes	for(ns = dp->nslist; ns; ns = ns->next) {
217238106Sdes		(*numns)++;
218238106Sdes		if(!ns->resolved)
219238106Sdes			(*missing)++;
220238106Sdes	}
221238106Sdes}
222238106Sdes
223238106Sdesvoid
224238106Sdesdelegpt_count_addr(struct delegpt* dp, size_t* numaddr, size_t* numres,
225238106Sdes	size_t* numavail)
226238106Sdes{
227238106Sdes	struct delegpt_addr* a;
228238106Sdes	*numaddr = 0;
229238106Sdes	*numres = 0;
230238106Sdes	*numavail = 0;
231238106Sdes	for(a = dp->target_list; a; a = a->next_target) {
232238106Sdes		(*numaddr)++;
233238106Sdes	}
234238106Sdes	for(a = dp->result_list; a; a = a->next_result) {
235238106Sdes		(*numres)++;
236238106Sdes	}
237238106Sdes	for(a = dp->usable_list; a; a = a->next_usable) {
238238106Sdes		(*numavail)++;
239238106Sdes	}
240238106Sdes}
241238106Sdes
242238106Sdesvoid delegpt_log(enum verbosity_value v, struct delegpt* dp)
243238106Sdes{
244238106Sdes	char buf[LDNS_MAX_DOMAINLEN+1];
245238106Sdes	struct delegpt_ns* ns;
246238106Sdes	struct delegpt_addr* a;
247238106Sdes	size_t missing=0, numns=0, numaddr=0, numres=0, numavail=0;
248238106Sdes	if(verbosity < v)
249238106Sdes		return;
250238106Sdes	dname_str(dp->name, buf);
251238106Sdes	if(dp->nslist == NULL && dp->target_list == NULL) {
252238106Sdes		log_info("DelegationPoint<%s>: empty", buf);
253238106Sdes		return;
254238106Sdes	}
255238106Sdes	delegpt_count_ns(dp, &numns, &missing);
256238106Sdes	delegpt_count_addr(dp, &numaddr, &numres, &numavail);
257238106Sdes	log_info("DelegationPoint<%s>: %u names (%u missing), "
258238106Sdes		"%u addrs (%u result, %u avail)%s",
259238106Sdes		buf, (unsigned)numns, (unsigned)missing,
260238106Sdes		(unsigned)numaddr, (unsigned)numres, (unsigned)numavail,
261238106Sdes		(dp->has_parent_side_NS?" parentNS":" cacheNS"));
262238106Sdes	if(verbosity >= VERB_ALGO) {
263238106Sdes		for(ns = dp->nslist; ns; ns = ns->next) {
264238106Sdes			dname_str(ns->name, buf);
265238106Sdes			log_info("  %s %s%s%s%s%s%s%s", buf,
266238106Sdes			(ns->resolved?"*":""),
267238106Sdes			(ns->got4?" A":""), (ns->got6?" AAAA":""),
268238106Sdes			(dp->bogus?" BOGUS":""), (ns->lame?" PARENTSIDE":""),
269238106Sdes			(ns->done_pside4?" PSIDE_A":""),
270238106Sdes			(ns->done_pside6?" PSIDE_AAAA":""));
271238106Sdes		}
272238106Sdes		for(a = dp->target_list; a; a = a->next_target) {
273238106Sdes			const char* str = "  ";
274238106Sdes			if(a->bogus && a->lame) str = "  BOGUS ADDR_LAME ";
275238106Sdes			else if(a->bogus) str = "  BOGUS ";
276238106Sdes			else if(a->lame) str = "  ADDR_LAME ";
277238106Sdes			log_addr(VERB_ALGO, str, &a->addr, a->addrlen);
278238106Sdes		}
279238106Sdes	}
280238106Sdes}
281238106Sdes
282238106Sdesvoid
283238106Sdesdelegpt_add_unused_targets(struct delegpt* dp)
284238106Sdes{
285238106Sdes	struct delegpt_addr* usa = dp->usable_list;
286238106Sdes	dp->usable_list = NULL;
287238106Sdes	while(usa) {
288238106Sdes		usa->next_result = dp->result_list;
289238106Sdes		dp->result_list = usa;
290238106Sdes		usa = usa->next_usable;
291238106Sdes	}
292238106Sdes}
293238106Sdes
294238106Sdessize_t
295238106Sdesdelegpt_count_targets(struct delegpt* dp)
296238106Sdes{
297238106Sdes	struct delegpt_addr* a;
298238106Sdes	size_t n = 0;
299238106Sdes	for(a = dp->target_list; a; a = a->next_target)
300238106Sdes		n++;
301238106Sdes	return n;
302238106Sdes}
303238106Sdes
304238106Sdessize_t
305238106Sdesdelegpt_count_missing_targets(struct delegpt* dp)
306238106Sdes{
307238106Sdes	struct delegpt_ns* ns;
308238106Sdes	size_t n = 0;
309238106Sdes	for(ns = dp->nslist; ns; ns = ns->next)
310238106Sdes		if(!ns->resolved)
311238106Sdes			n++;
312238106Sdes	return n;
313238106Sdes}
314238106Sdes
315238106Sdes/** find NS rrset in given list */
316238106Sdesstatic struct ub_packed_rrset_key*
317238106Sdesfind_NS(struct reply_info* rep, size_t from, size_t to)
318238106Sdes{
319238106Sdes	size_t i;
320238106Sdes	for(i=from; i<to; i++) {
321238106Sdes		if(ntohs(rep->rrsets[i]->rk.type) == LDNS_RR_TYPE_NS)
322238106Sdes			return rep->rrsets[i];
323238106Sdes	}
324238106Sdes	return NULL;
325238106Sdes}
326238106Sdes
327238106Sdesstruct delegpt*
328238106Sdesdelegpt_from_message(struct dns_msg* msg, struct regional* region)
329238106Sdes{
330238106Sdes	struct ub_packed_rrset_key* ns_rrset = NULL;
331238106Sdes	struct delegpt* dp;
332238106Sdes	size_t i;
333238106Sdes	/* look for NS records in the authority section... */
334238106Sdes	ns_rrset = find_NS(msg->rep, msg->rep->an_numrrsets,
335238106Sdes		msg->rep->an_numrrsets+msg->rep->ns_numrrsets);
336238106Sdes
337238106Sdes	/* In some cases (even legitimate, perfectly legal cases), the
338238106Sdes	 * NS set for the "referral" might be in the answer section. */
339238106Sdes	if(!ns_rrset)
340238106Sdes		ns_rrset = find_NS(msg->rep, 0, msg->rep->an_numrrsets);
341238106Sdes
342238106Sdes	/* If there was no NS rrset in the authority section, then this
343238106Sdes	 * wasn't a referral message. (It might not actually be a
344238106Sdes	 * referral message anyway) */
345238106Sdes	if(!ns_rrset)
346238106Sdes		return NULL;
347238106Sdes
348238106Sdes	/* If we found any, then Yay! we have a delegation point. */
349238106Sdes	dp = delegpt_create(region);
350238106Sdes	if(!dp)
351238106Sdes		return NULL;
352238106Sdes	dp->has_parent_side_NS = 1; /* created from message */
353238106Sdes	if(!delegpt_set_name(dp, region, ns_rrset->rk.dname))
354238106Sdes		return NULL;
355238106Sdes	if(!delegpt_rrset_add_ns(dp, region, ns_rrset, 0))
356238106Sdes		return NULL;
357238106Sdes
358238106Sdes	/* add glue, A and AAAA in answer and additional section */
359238106Sdes	for(i=0; i<msg->rep->rrset_count; i++) {
360238106Sdes		struct ub_packed_rrset_key* s = msg->rep->rrsets[i];
361238106Sdes		/* skip auth section. FIXME really needed?*/
362238106Sdes		if(msg->rep->an_numrrsets <= i &&
363238106Sdes			i < (msg->rep->an_numrrsets+msg->rep->ns_numrrsets))
364238106Sdes			continue;
365238106Sdes
366238106Sdes		if(ntohs(s->rk.type) == LDNS_RR_TYPE_A) {
367238106Sdes			if(!delegpt_add_rrset_A(dp, region, s, 0))
368238106Sdes				return NULL;
369238106Sdes		} else if(ntohs(s->rk.type) == LDNS_RR_TYPE_AAAA) {
370238106Sdes			if(!delegpt_add_rrset_AAAA(dp, region, s, 0))
371238106Sdes				return NULL;
372238106Sdes		}
373238106Sdes	}
374238106Sdes	return dp;
375238106Sdes}
376238106Sdes
377238106Sdesint
378238106Sdesdelegpt_rrset_add_ns(struct delegpt* dp, struct regional* region,
379238106Sdes        struct ub_packed_rrset_key* ns_rrset, int lame)
380238106Sdes{
381238106Sdes	struct packed_rrset_data* nsdata = (struct packed_rrset_data*)
382238106Sdes		ns_rrset->entry.data;
383238106Sdes	size_t i;
384238106Sdes	log_assert(!dp->dp_type_mlc);
385238106Sdes	if(nsdata->security == sec_status_bogus)
386238106Sdes		dp->bogus = 1;
387238106Sdes	for(i=0; i<nsdata->count; i++) {
388238106Sdes		if(nsdata->rr_len[i] < 2+1) continue; /* len + root label */
389238106Sdes		if(dname_valid(nsdata->rr_data[i]+2, nsdata->rr_len[i]-2) !=
390238106Sdes			(size_t)ldns_read_uint16(nsdata->rr_data[i]))
391238106Sdes			continue; /* bad format */
392238106Sdes		/* add rdata of NS (= wirefmt dname), skip rdatalen bytes */
393238106Sdes		if(!delegpt_add_ns(dp, region, nsdata->rr_data[i]+2, lame))
394238106Sdes			return 0;
395238106Sdes	}
396238106Sdes	return 1;
397238106Sdes}
398238106Sdes
399238106Sdesint
400238106Sdesdelegpt_add_rrset_A(struct delegpt* dp, struct regional* region,
401238106Sdes	struct ub_packed_rrset_key* ak, int lame)
402238106Sdes{
403238106Sdes        struct packed_rrset_data* d=(struct packed_rrset_data*)ak->entry.data;
404238106Sdes        size_t i;
405238106Sdes        struct sockaddr_in sa;
406238106Sdes        socklen_t len = (socklen_t)sizeof(sa);
407238106Sdes	log_assert(!dp->dp_type_mlc);
408238106Sdes        memset(&sa, 0, len);
409238106Sdes        sa.sin_family = AF_INET;
410238106Sdes        sa.sin_port = (in_port_t)htons(UNBOUND_DNS_PORT);
411238106Sdes        for(i=0; i<d->count; i++) {
412238106Sdes                if(d->rr_len[i] != 2 + INET_SIZE)
413238106Sdes                        continue;
414238106Sdes                memmove(&sa.sin_addr, d->rr_data[i]+2, INET_SIZE);
415238106Sdes                if(!delegpt_add_target(dp, region, ak->rk.dname,
416238106Sdes                        ak->rk.dname_len, (struct sockaddr_storage*)&sa,
417238106Sdes                        len, (d->security==sec_status_bogus), lame))
418238106Sdes                        return 0;
419238106Sdes        }
420238106Sdes        return 1;
421238106Sdes}
422238106Sdes
423238106Sdesint
424238106Sdesdelegpt_add_rrset_AAAA(struct delegpt* dp, struct regional* region,
425238106Sdes	struct ub_packed_rrset_key* ak, int lame)
426238106Sdes{
427238106Sdes        struct packed_rrset_data* d=(struct packed_rrset_data*)ak->entry.data;
428238106Sdes        size_t i;
429238106Sdes        struct sockaddr_in6 sa;
430238106Sdes        socklen_t len = (socklen_t)sizeof(sa);
431238106Sdes	log_assert(!dp->dp_type_mlc);
432238106Sdes        memset(&sa, 0, len);
433238106Sdes        sa.sin6_family = AF_INET6;
434238106Sdes        sa.sin6_port = (in_port_t)htons(UNBOUND_DNS_PORT);
435238106Sdes        for(i=0; i<d->count; i++) {
436238106Sdes                if(d->rr_len[i] != 2 + INET6_SIZE) /* rdatalen + len of IP6 */
437238106Sdes                        continue;
438238106Sdes                memmove(&sa.sin6_addr, d->rr_data[i]+2, INET6_SIZE);
439238106Sdes                if(!delegpt_add_target(dp, region, ak->rk.dname,
440238106Sdes                        ak->rk.dname_len, (struct sockaddr_storage*)&sa,
441238106Sdes                        len, (d->security==sec_status_bogus), lame))
442238106Sdes                        return 0;
443238106Sdes        }
444238106Sdes        return 1;
445238106Sdes}
446238106Sdes
447238106Sdesint
448238106Sdesdelegpt_add_rrset(struct delegpt* dp, struct regional* region,
449238106Sdes        struct ub_packed_rrset_key* rrset, int lame)
450238106Sdes{
451238106Sdes	if(!rrset)
452238106Sdes		return 1;
453238106Sdes	if(ntohs(rrset->rk.type) == LDNS_RR_TYPE_NS)
454238106Sdes		return delegpt_rrset_add_ns(dp, region, rrset, lame);
455238106Sdes	else if(ntohs(rrset->rk.type) == LDNS_RR_TYPE_A)
456238106Sdes		return delegpt_add_rrset_A(dp, region, rrset, lame);
457238106Sdes	else if(ntohs(rrset->rk.type) == LDNS_RR_TYPE_AAAA)
458238106Sdes		return delegpt_add_rrset_AAAA(dp, region, rrset, lame);
459238106Sdes	log_warn("Unknown rrset type added to delegpt");
460238106Sdes	return 1;
461238106Sdes}
462238106Sdes
463238106Sdesvoid delegpt_add_neg_msg(struct delegpt* dp, struct msgreply_entry* msg)
464238106Sdes{
465238106Sdes	struct reply_info* rep = (struct reply_info*)msg->entry.data;
466238106Sdes	if(!rep) return;
467238106Sdes
468238106Sdes	/* if error or no answers */
469238106Sdes	if(FLAGS_GET_RCODE(rep->flags) != 0 || rep->an_numrrsets == 0) {
470238106Sdes		struct delegpt_ns* ns = delegpt_find_ns(dp, msg->key.qname,
471238106Sdes			msg->key.qname_len);
472238106Sdes		if(ns) {
473238106Sdes			if(msg->key.qtype == LDNS_RR_TYPE_A)
474238106Sdes				ns->got4 = 1;
475238106Sdes			else if(msg->key.qtype == LDNS_RR_TYPE_AAAA)
476238106Sdes				ns->got6 = 1;
477238106Sdes			if(ns->got4 && ns->got6)
478238106Sdes				ns->resolved = 1;
479238106Sdes		}
480238106Sdes	}
481238106Sdes}
482238106Sdes
483238106Sdesvoid delegpt_no_ipv6(struct delegpt* dp)
484238106Sdes{
485238106Sdes	struct delegpt_ns* ns;
486238106Sdes	for(ns = dp->nslist; ns; ns = ns->next) {
487238106Sdes		/* no ipv6, so only ipv4 is enough to resolve a nameserver */
488238106Sdes		if(ns->got4)
489238106Sdes			ns->resolved = 1;
490238106Sdes	}
491238106Sdes}
492238106Sdes
493238106Sdesvoid delegpt_no_ipv4(struct delegpt* dp)
494238106Sdes{
495238106Sdes	struct delegpt_ns* ns;
496238106Sdes	for(ns = dp->nslist; ns; ns = ns->next) {
497238106Sdes		/* no ipv4, so only ipv6 is enough to resolve a nameserver */
498238106Sdes		if(ns->got6)
499238106Sdes			ns->resolved = 1;
500238106Sdes	}
501238106Sdes}
502238106Sdes
503238106Sdesstruct delegpt* delegpt_create_mlc(uint8_t* name)
504238106Sdes{
505238106Sdes	struct delegpt* dp=(struct delegpt*)calloc(1, sizeof(*dp));
506238106Sdes	if(!dp)
507238106Sdes		return NULL;
508238106Sdes	dp->dp_type_mlc = 1;
509238106Sdes	if(name) {
510238106Sdes		dp->namelabs = dname_count_size_labels(name, &dp->namelen);
511238106Sdes		dp->name = memdup(name, dp->namelen);
512238106Sdes		if(!dp->name) {
513238106Sdes			free(dp);
514238106Sdes			return NULL;
515238106Sdes		}
516238106Sdes	}
517238106Sdes	return dp;
518238106Sdes}
519238106Sdes
520238106Sdesvoid delegpt_free_mlc(struct delegpt* dp)
521238106Sdes{
522238106Sdes	struct delegpt_ns* n, *nn;
523238106Sdes	struct delegpt_addr* a, *na;
524238106Sdes	if(!dp) return;
525238106Sdes	log_assert(dp->dp_type_mlc);
526238106Sdes	n = dp->nslist;
527238106Sdes	while(n) {
528238106Sdes		nn = n->next;
529238106Sdes		free(n->name);
530238106Sdes		free(n);
531238106Sdes		n = nn;
532238106Sdes	}
533238106Sdes	a = dp->target_list;
534238106Sdes	while(a) {
535238106Sdes		na = a->next_target;
536238106Sdes		free(a);
537238106Sdes		a = na;
538238106Sdes	}
539238106Sdes	free(dp->name);
540238106Sdes	free(dp);
541238106Sdes}
542238106Sdes
543238106Sdesint delegpt_set_name_mlc(struct delegpt* dp, uint8_t* name)
544238106Sdes{
545238106Sdes	log_assert(dp->dp_type_mlc);
546238106Sdes	dp->namelabs = dname_count_size_labels(name, &dp->namelen);
547238106Sdes	dp->name = memdup(name, dp->namelen);
548238106Sdes	return (dp->name != NULL);
549238106Sdes}
550238106Sdes
551238106Sdesint delegpt_add_ns_mlc(struct delegpt* dp, uint8_t* name, int lame)
552238106Sdes{
553238106Sdes	struct delegpt_ns* ns;
554238106Sdes	size_t len;
555238106Sdes	(void)dname_count_size_labels(name, &len);
556238106Sdes	log_assert(dp->dp_type_mlc);
557238106Sdes	/* slow check for duplicates to avoid counting failures when
558238106Sdes	 * adding the same server as a dependency twice */
559238106Sdes	if(delegpt_find_ns(dp, name, len))
560238106Sdes		return 1;
561238106Sdes	ns = (struct delegpt_ns*)malloc(sizeof(struct delegpt_ns));
562238106Sdes	if(!ns)
563238106Sdes		return 0;
564238106Sdes	ns->namelen = len;
565238106Sdes	ns->name = memdup(name, ns->namelen);
566238106Sdes	if(!ns->name) {
567238106Sdes		free(ns);
568238106Sdes		return 0;
569238106Sdes	}
570238106Sdes	ns->next = dp->nslist;
571238106Sdes	dp->nslist = ns;
572238106Sdes	ns->resolved = 0;
573238106Sdes	ns->got4 = 0;
574238106Sdes	ns->got6 = 0;
575238106Sdes	ns->lame = (uint8_t)lame;
576238106Sdes	ns->done_pside4 = 0;
577238106Sdes	ns->done_pside6 = 0;
578238106Sdes	return 1;
579238106Sdes}
580238106Sdes
581238106Sdesint delegpt_add_addr_mlc(struct delegpt* dp, struct sockaddr_storage* addr,
582238106Sdes	socklen_t addrlen, int bogus, int lame)
583238106Sdes{
584238106Sdes	struct delegpt_addr* a;
585238106Sdes	log_assert(dp->dp_type_mlc);
586238106Sdes	/* check for duplicates */
587238106Sdes	if((a = delegpt_find_addr(dp, addr, addrlen))) {
588238106Sdes		if(bogus)
589238106Sdes			a->bogus = bogus;
590238106Sdes		if(!lame)
591238106Sdes			a->lame = 0;
592238106Sdes		return 1;
593238106Sdes	}
594238106Sdes
595238106Sdes	a = (struct delegpt_addr*)malloc(sizeof(struct delegpt_addr));
596238106Sdes	if(!a)
597238106Sdes		return 0;
598238106Sdes	a->next_target = dp->target_list;
599238106Sdes	dp->target_list = a;
600238106Sdes	a->next_result = 0;
601238106Sdes	a->next_usable = dp->usable_list;
602238106Sdes	dp->usable_list = a;
603238106Sdes	memcpy(&a->addr, addr, addrlen);
604238106Sdes	a->addrlen = addrlen;
605238106Sdes	a->attempts = 0;
606238106Sdes	a->bogus = bogus;
607238106Sdes	a->lame = lame;
608238106Sdes	return 1;
609238106Sdes}
610238106Sdes
611238106Sdesint delegpt_add_target_mlc(struct delegpt* dp, uint8_t* name, size_t namelen,
612238106Sdes	struct sockaddr_storage* addr, socklen_t addrlen, int bogus, int lame)
613238106Sdes{
614238106Sdes	struct delegpt_ns* ns = delegpt_find_ns(dp, name, namelen);
615238106Sdes	log_assert(dp->dp_type_mlc);
616238106Sdes	if(!ns) {
617238106Sdes		/* ignore it */
618238106Sdes		return 1;
619238106Sdes	}
620238106Sdes	if(!lame) {
621238106Sdes		if(addr_is_ip6(addr, addrlen))
622238106Sdes			ns->got6 = 1;
623238106Sdes		else	ns->got4 = 1;
624238106Sdes		if(ns->got4 && ns->got6)
625238106Sdes			ns->resolved = 1;
626238106Sdes	}
627238106Sdes	return delegpt_add_addr_mlc(dp, addr, addrlen, bogus, lame);
628238106Sdes}
629238106Sdes
630238106Sdessize_t delegpt_get_mem(struct delegpt* dp)
631238106Sdes{
632238106Sdes	struct delegpt_ns* ns;
633238106Sdes	size_t s;
634238106Sdes	if(!dp) return 0;
635238106Sdes	s = sizeof(*dp) + dp->namelen +
636238106Sdes		delegpt_count_targets(dp)*sizeof(struct delegpt_addr);
637238106Sdes	for(ns=dp->nslist; ns; ns=ns->next)
638238106Sdes		s += sizeof(*ns)+ns->namelen;
639238106Sdes	return s;
640238106Sdes}
641