xref: /freebsd/contrib/unbound/services/mesh.c (revision 8a384985ac088991f98ea10dda56816f137ce55e)
1b7579f77SDag-Erling Smørgrav /*
2b7579f77SDag-Erling Smørgrav  * services/mesh.c - deal with mesh of query states and handle events for that.
3b7579f77SDag-Erling Smørgrav  *
4b7579f77SDag-Erling Smørgrav  * Copyright (c) 2007, NLnet Labs. All rights reserved.
5b7579f77SDag-Erling Smørgrav  *
6b7579f77SDag-Erling Smørgrav  * This software is open source.
7b7579f77SDag-Erling Smørgrav  *
8b7579f77SDag-Erling Smørgrav  * Redistribution and use in source and binary forms, with or without
9b7579f77SDag-Erling Smørgrav  * modification, are permitted provided that the following conditions
10b7579f77SDag-Erling Smørgrav  * are met:
11b7579f77SDag-Erling Smørgrav  *
12b7579f77SDag-Erling Smørgrav  * Redistributions of source code must retain the above copyright notice,
13b7579f77SDag-Erling Smørgrav  * this list of conditions and the following disclaimer.
14b7579f77SDag-Erling Smørgrav  *
15b7579f77SDag-Erling Smørgrav  * Redistributions in binary form must reproduce the above copyright notice,
16b7579f77SDag-Erling Smørgrav  * this list of conditions and the following disclaimer in the documentation
17b7579f77SDag-Erling Smørgrav  * and/or other materials provided with the distribution.
18b7579f77SDag-Erling Smørgrav  *
19b7579f77SDag-Erling Smørgrav  * Neither the name of the NLNET LABS nor the names of its contributors may
20b7579f77SDag-Erling Smørgrav  * be used to endorse or promote products derived from this software without
21b7579f77SDag-Erling Smørgrav  * specific prior written permission.
22b7579f77SDag-Erling Smørgrav  *
23b7579f77SDag-Erling Smørgrav  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
2417d15b25SDag-Erling Smørgrav  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
2517d15b25SDag-Erling Smørgrav  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
2617d15b25SDag-Erling Smørgrav  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
2717d15b25SDag-Erling Smørgrav  * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
2817d15b25SDag-Erling Smørgrav  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
2917d15b25SDag-Erling Smørgrav  * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
3017d15b25SDag-Erling Smørgrav  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
3117d15b25SDag-Erling Smørgrav  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
3217d15b25SDag-Erling Smørgrav  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
3317d15b25SDag-Erling Smørgrav  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
34b7579f77SDag-Erling Smørgrav  */
35b7579f77SDag-Erling Smørgrav 
36b7579f77SDag-Erling Smørgrav /**
37b7579f77SDag-Erling Smørgrav  * \file
38b7579f77SDag-Erling Smørgrav  *
39b7579f77SDag-Erling Smørgrav  * This file contains functions to assist in dealing with a mesh of
40b7579f77SDag-Erling Smørgrav  * query states. This mesh is supposed to be thread-specific.
41b7579f77SDag-Erling Smørgrav  * It consists of query states (per qname, qtype, qclass) and connections
42b7579f77SDag-Erling Smørgrav  * between query states and the super and subquery states, and replies to
43b7579f77SDag-Erling Smørgrav  * send back to clients.
44b7579f77SDag-Erling Smørgrav  */
45b7579f77SDag-Erling Smørgrav #include "config.h"
46b7579f77SDag-Erling Smørgrav #include "services/mesh.h"
47b7579f77SDag-Erling Smørgrav #include "services/outbound_list.h"
48b7579f77SDag-Erling Smørgrav #include "services/cache/dns.h"
49b7579f77SDag-Erling Smørgrav #include "util/log.h"
50b7579f77SDag-Erling Smørgrav #include "util/net_help.h"
51b7579f77SDag-Erling Smørgrav #include "util/module.h"
52b7579f77SDag-Erling Smørgrav #include "util/regional.h"
53b7579f77SDag-Erling Smørgrav #include "util/data/msgencode.h"
54b7579f77SDag-Erling Smørgrav #include "util/timehist.h"
55b7579f77SDag-Erling Smørgrav #include "util/fptr_wlist.h"
56b7579f77SDag-Erling Smørgrav #include "util/alloc.h"
57b7579f77SDag-Erling Smørgrav #include "util/config_file.h"
5809a3aaf3SDag-Erling Smørgrav #include "sldns/sbuffer.h"
59bc892140SDag-Erling Smørgrav #include "sldns/wire2str.h"
60bc892140SDag-Erling Smørgrav #include "services/localzone.h"
61bc892140SDag-Erling Smørgrav #include "util/data/dname.h"
6265b390aaSDag-Erling Smørgrav #include "respip/respip.h"
63b7579f77SDag-Erling Smørgrav 
64b7579f77SDag-Erling Smørgrav /** subtract timers and the values do not overflow or become negative */
65b7579f77SDag-Erling Smørgrav static void
66b7579f77SDag-Erling Smørgrav timeval_subtract(struct timeval* d, const struct timeval* end, const struct timeval* start)
67b7579f77SDag-Erling Smørgrav {
68b7579f77SDag-Erling Smørgrav #ifndef S_SPLINT_S
69b7579f77SDag-Erling Smørgrav 	time_t end_usec = end->tv_usec;
70b7579f77SDag-Erling Smørgrav 	d->tv_sec = end->tv_sec - start->tv_sec;
71b7579f77SDag-Erling Smørgrav 	if(end_usec < start->tv_usec) {
72b7579f77SDag-Erling Smørgrav 		end_usec += 1000000;
73b7579f77SDag-Erling Smørgrav 		d->tv_sec--;
74b7579f77SDag-Erling Smørgrav 	}
75b7579f77SDag-Erling Smørgrav 	d->tv_usec = end_usec - start->tv_usec;
76b7579f77SDag-Erling Smørgrav #endif
77b7579f77SDag-Erling Smørgrav }
78b7579f77SDag-Erling Smørgrav 
79b7579f77SDag-Erling Smørgrav /** add timers and the values do not overflow or become negative */
80b7579f77SDag-Erling Smørgrav static void
81b7579f77SDag-Erling Smørgrav timeval_add(struct timeval* d, const struct timeval* add)
82b7579f77SDag-Erling Smørgrav {
83b7579f77SDag-Erling Smørgrav #ifndef S_SPLINT_S
84b7579f77SDag-Erling Smørgrav 	d->tv_sec += add->tv_sec;
85b7579f77SDag-Erling Smørgrav 	d->tv_usec += add->tv_usec;
86b7579f77SDag-Erling Smørgrav 	if(d->tv_usec > 1000000 ) {
87b7579f77SDag-Erling Smørgrav 		d->tv_usec -= 1000000;
88b7579f77SDag-Erling Smørgrav 		d->tv_sec++;
89b7579f77SDag-Erling Smørgrav 	}
90b7579f77SDag-Erling Smørgrav #endif
91b7579f77SDag-Erling Smørgrav }
92b7579f77SDag-Erling Smørgrav 
93b7579f77SDag-Erling Smørgrav /** divide sum of timers to get average */
94b7579f77SDag-Erling Smørgrav static void
95b7579f77SDag-Erling Smørgrav timeval_divide(struct timeval* avg, const struct timeval* sum, size_t d)
96b7579f77SDag-Erling Smørgrav {
97b7579f77SDag-Erling Smørgrav #ifndef S_SPLINT_S
98b7579f77SDag-Erling Smørgrav 	size_t leftover;
99b7579f77SDag-Erling Smørgrav 	if(d == 0) {
100b7579f77SDag-Erling Smørgrav 		avg->tv_sec = 0;
101b7579f77SDag-Erling Smørgrav 		avg->tv_usec = 0;
102b7579f77SDag-Erling Smørgrav 		return;
103b7579f77SDag-Erling Smørgrav 	}
104b7579f77SDag-Erling Smørgrav 	avg->tv_sec = sum->tv_sec / d;
105b7579f77SDag-Erling Smørgrav 	avg->tv_usec = sum->tv_usec / d;
106b7579f77SDag-Erling Smørgrav 	/* handle fraction from seconds divide */
107b7579f77SDag-Erling Smørgrav 	leftover = sum->tv_sec - avg->tv_sec*d;
108b7579f77SDag-Erling Smørgrav 	avg->tv_usec += (leftover*1000000)/d;
109b7579f77SDag-Erling Smørgrav #endif
110b7579f77SDag-Erling Smørgrav }
111b7579f77SDag-Erling Smørgrav 
112b7579f77SDag-Erling Smørgrav /** histogram compare of time values */
113b7579f77SDag-Erling Smørgrav static int
114b7579f77SDag-Erling Smørgrav timeval_smaller(const struct timeval* x, const struct timeval* y)
115b7579f77SDag-Erling Smørgrav {
116b7579f77SDag-Erling Smørgrav #ifndef S_SPLINT_S
117b7579f77SDag-Erling Smørgrav 	if(x->tv_sec < y->tv_sec)
118b7579f77SDag-Erling Smørgrav 		return 1;
119b7579f77SDag-Erling Smørgrav 	else if(x->tv_sec == y->tv_sec) {
120b7579f77SDag-Erling Smørgrav 		if(x->tv_usec <= y->tv_usec)
121b7579f77SDag-Erling Smørgrav 			return 1;
122b7579f77SDag-Erling Smørgrav 		else	return 0;
123b7579f77SDag-Erling Smørgrav 	}
124b7579f77SDag-Erling Smørgrav 	else	return 0;
125b7579f77SDag-Erling Smørgrav #endif
126b7579f77SDag-Erling Smørgrav }
127b7579f77SDag-Erling Smørgrav 
12865b390aaSDag-Erling Smørgrav /*
12965b390aaSDag-Erling Smørgrav  * Compare two response-ip client info entries for the purpose of mesh state
13065b390aaSDag-Erling Smørgrav  * compare.  It returns 0 if ci_a and ci_b are considered equal; otherwise
13165b390aaSDag-Erling Smørgrav  * 1 or -1 (they mean 'ci_a is larger/smaller than ci_b', respectively, but
13265b390aaSDag-Erling Smørgrav  * in practice it should be only used to mean they are different).
13365b390aaSDag-Erling Smørgrav  * We cannot share the mesh state for two queries if different response-ip
13465b390aaSDag-Erling Smørgrav  * actions can apply in the end, even if those queries are otherwise identical.
13565b390aaSDag-Erling Smørgrav  * For this purpose we compare tag lists and tag action lists; they should be
13665b390aaSDag-Erling Smørgrav  * identical to share the same state.
13765b390aaSDag-Erling Smørgrav  * For tag data, we don't look into the data content, as it can be
13865b390aaSDag-Erling Smørgrav  * expensive; unless tag data are not defined for both or they point to the
13965b390aaSDag-Erling Smørgrav  * exact same data in memory (i.e., they come from the same ACL entry), we
14065b390aaSDag-Erling Smørgrav  * consider these data different.
14165b390aaSDag-Erling Smørgrav  * Likewise, if the client info is associated with views, we don't look into
14265b390aaSDag-Erling Smørgrav  * the views.  They are considered different unless they are exactly the same
14365b390aaSDag-Erling Smørgrav  * even if the views only differ in the names.
14465b390aaSDag-Erling Smørgrav  */
14565b390aaSDag-Erling Smørgrav static int
14665b390aaSDag-Erling Smørgrav client_info_compare(const struct respip_client_info* ci_a,
14765b390aaSDag-Erling Smørgrav 	const struct respip_client_info* ci_b)
14865b390aaSDag-Erling Smørgrav {
14965b390aaSDag-Erling Smørgrav 	int cmp;
15065b390aaSDag-Erling Smørgrav 
15165b390aaSDag-Erling Smørgrav 	if(!ci_a && !ci_b)
15265b390aaSDag-Erling Smørgrav 		return 0;
15365b390aaSDag-Erling Smørgrav 	if(ci_a && !ci_b)
15465b390aaSDag-Erling Smørgrav 		return -1;
15565b390aaSDag-Erling Smørgrav 	if(!ci_a && ci_b)
15665b390aaSDag-Erling Smørgrav 		return 1;
15765b390aaSDag-Erling Smørgrav 	if(ci_a->taglen != ci_b->taglen)
15865b390aaSDag-Erling Smørgrav 		return (ci_a->taglen < ci_b->taglen) ? -1 : 1;
15965b390aaSDag-Erling Smørgrav 	cmp = memcmp(ci_a->taglist, ci_b->taglist, ci_a->taglen);
16065b390aaSDag-Erling Smørgrav 	if(cmp != 0)
16165b390aaSDag-Erling Smørgrav 		return cmp;
16265b390aaSDag-Erling Smørgrav 	if(ci_a->tag_actions_size != ci_b->tag_actions_size)
16365b390aaSDag-Erling Smørgrav 		return (ci_a->tag_actions_size < ci_b->tag_actions_size) ?
16465b390aaSDag-Erling Smørgrav 			-1 : 1;
16565b390aaSDag-Erling Smørgrav 	cmp = memcmp(ci_a->tag_actions, ci_b->tag_actions,
16665b390aaSDag-Erling Smørgrav 		ci_a->tag_actions_size);
16765b390aaSDag-Erling Smørgrav 	if(cmp != 0)
16865b390aaSDag-Erling Smørgrav 		return cmp;
16965b390aaSDag-Erling Smørgrav 	if(ci_a->tag_datas != ci_b->tag_datas)
17065b390aaSDag-Erling Smørgrav 		return ci_a->tag_datas < ci_b->tag_datas ? -1 : 1;
17165b390aaSDag-Erling Smørgrav 	if(ci_a->view != ci_b->view)
17265b390aaSDag-Erling Smørgrav 		return ci_a->view < ci_b->view ? -1 : 1;
17365b390aaSDag-Erling Smørgrav 	/* For the unbound daemon these should be non-NULL and identical,
17465b390aaSDag-Erling Smørgrav 	 * but we check that just in case. */
17565b390aaSDag-Erling Smørgrav 	if(ci_a->respip_set != ci_b->respip_set)
17665b390aaSDag-Erling Smørgrav 		return ci_a->respip_set < ci_b->respip_set ? -1 : 1;
17765b390aaSDag-Erling Smørgrav 	return 0;
17865b390aaSDag-Erling Smørgrav }
17965b390aaSDag-Erling Smørgrav 
180b7579f77SDag-Erling Smørgrav int
181b7579f77SDag-Erling Smørgrav mesh_state_compare(const void* ap, const void* bp)
182b7579f77SDag-Erling Smørgrav {
183b7579f77SDag-Erling Smørgrav 	struct mesh_state* a = (struct mesh_state*)ap;
184b7579f77SDag-Erling Smørgrav 	struct mesh_state* b = (struct mesh_state*)bp;
18565b390aaSDag-Erling Smørgrav 	int cmp;
186b7579f77SDag-Erling Smørgrav 
187bc892140SDag-Erling Smørgrav 	if(a->unique < b->unique)
188bc892140SDag-Erling Smørgrav 		return -1;
189bc892140SDag-Erling Smørgrav 	if(a->unique > b->unique)
190bc892140SDag-Erling Smørgrav 		return 1;
191bc892140SDag-Erling Smørgrav 
192b7579f77SDag-Erling Smørgrav 	if(a->s.is_priming && !b->s.is_priming)
193b7579f77SDag-Erling Smørgrav 		return -1;
194b7579f77SDag-Erling Smørgrav 	if(!a->s.is_priming && b->s.is_priming)
195b7579f77SDag-Erling Smørgrav 		return 1;
196b7579f77SDag-Erling Smørgrav 
197ff825849SDag-Erling Smørgrav 	if(a->s.is_valrec && !b->s.is_valrec)
198ff825849SDag-Erling Smørgrav 		return -1;
199ff825849SDag-Erling Smørgrav 	if(!a->s.is_valrec && b->s.is_valrec)
200ff825849SDag-Erling Smørgrav 		return 1;
201ff825849SDag-Erling Smørgrav 
202b7579f77SDag-Erling Smørgrav 	if((a->s.query_flags&BIT_RD) && !(b->s.query_flags&BIT_RD))
203b7579f77SDag-Erling Smørgrav 		return -1;
204b7579f77SDag-Erling Smørgrav 	if(!(a->s.query_flags&BIT_RD) && (b->s.query_flags&BIT_RD))
205b7579f77SDag-Erling Smørgrav 		return 1;
206b7579f77SDag-Erling Smørgrav 
207b7579f77SDag-Erling Smørgrav 	if((a->s.query_flags&BIT_CD) && !(b->s.query_flags&BIT_CD))
208b7579f77SDag-Erling Smørgrav 		return -1;
209b7579f77SDag-Erling Smørgrav 	if(!(a->s.query_flags&BIT_CD) && (b->s.query_flags&BIT_CD))
210b7579f77SDag-Erling Smørgrav 		return 1;
211b7579f77SDag-Erling Smørgrav 
21265b390aaSDag-Erling Smørgrav 	cmp = query_info_compare(&a->s.qinfo, &b->s.qinfo);
21365b390aaSDag-Erling Smørgrav 	if(cmp != 0)
21465b390aaSDag-Erling Smørgrav 		return cmp;
21565b390aaSDag-Erling Smørgrav 	return client_info_compare(a->s.client_info, b->s.client_info);
216b7579f77SDag-Erling Smørgrav }
217b7579f77SDag-Erling Smørgrav 
218b7579f77SDag-Erling Smørgrav int
219b7579f77SDag-Erling Smørgrav mesh_state_ref_compare(const void* ap, const void* bp)
220b7579f77SDag-Erling Smørgrav {
221b7579f77SDag-Erling Smørgrav 	struct mesh_state_ref* a = (struct mesh_state_ref*)ap;
222b7579f77SDag-Erling Smørgrav 	struct mesh_state_ref* b = (struct mesh_state_ref*)bp;
223b7579f77SDag-Erling Smørgrav 	return mesh_state_compare(a->s, b->s);
224b7579f77SDag-Erling Smørgrav }
225b7579f77SDag-Erling Smørgrav 
226b7579f77SDag-Erling Smørgrav struct mesh_area*
227b7579f77SDag-Erling Smørgrav mesh_create(struct module_stack* stack, struct module_env* env)
228b7579f77SDag-Erling Smørgrav {
229b7579f77SDag-Erling Smørgrav 	struct mesh_area* mesh = calloc(1, sizeof(struct mesh_area));
230b7579f77SDag-Erling Smørgrav 	if(!mesh) {
231b7579f77SDag-Erling Smørgrav 		log_err("mesh area alloc: out of memory");
232b7579f77SDag-Erling Smørgrav 		return NULL;
233b7579f77SDag-Erling Smørgrav 	}
234b7579f77SDag-Erling Smørgrav 	mesh->histogram = timehist_setup();
23517d15b25SDag-Erling Smørgrav 	mesh->qbuf_bak = sldns_buffer_new(env->cfg->msg_buffer_size);
236b7579f77SDag-Erling Smørgrav 	if(!mesh->histogram || !mesh->qbuf_bak) {
237b7579f77SDag-Erling Smørgrav 		free(mesh);
238b7579f77SDag-Erling Smørgrav 		log_err("mesh area alloc: out of memory");
239b7579f77SDag-Erling Smørgrav 		return NULL;
240b7579f77SDag-Erling Smørgrav 	}
241b7579f77SDag-Erling Smørgrav 	mesh->mods = *stack;
242b7579f77SDag-Erling Smørgrav 	mesh->env = env;
243b7579f77SDag-Erling Smørgrav 	rbtree_init(&mesh->run, &mesh_state_compare);
244b7579f77SDag-Erling Smørgrav 	rbtree_init(&mesh->all, &mesh_state_compare);
245b7579f77SDag-Erling Smørgrav 	mesh->num_reply_addrs = 0;
246b7579f77SDag-Erling Smørgrav 	mesh->num_reply_states = 0;
247b7579f77SDag-Erling Smørgrav 	mesh->num_detached_states = 0;
248b7579f77SDag-Erling Smørgrav 	mesh->num_forever_states = 0;
249b7579f77SDag-Erling Smørgrav 	mesh->stats_jostled = 0;
250b7579f77SDag-Erling Smørgrav 	mesh->stats_dropped = 0;
251b7579f77SDag-Erling Smørgrav 	mesh->max_reply_states = env->cfg->num_queries_per_thread;
252b7579f77SDag-Erling Smørgrav 	mesh->max_forever_states = (mesh->max_reply_states+1)/2;
253b7579f77SDag-Erling Smørgrav #ifndef S_SPLINT_S
254b7579f77SDag-Erling Smørgrav 	mesh->jostle_max.tv_sec = (time_t)(env->cfg->jostle_time / 1000);
255b7579f77SDag-Erling Smørgrav 	mesh->jostle_max.tv_usec = (time_t)((env->cfg->jostle_time % 1000)
256b7579f77SDag-Erling Smørgrav 		*1000);
257b7579f77SDag-Erling Smørgrav #endif
258b7579f77SDag-Erling Smørgrav 	return mesh;
259b7579f77SDag-Erling Smørgrav }
260b7579f77SDag-Erling Smørgrav 
261b7579f77SDag-Erling Smørgrav /** help mesh delete delete mesh states */
262b7579f77SDag-Erling Smørgrav static void
2633005e0a3SDag-Erling Smørgrav mesh_delete_helper(rbnode_type* n)
264b7579f77SDag-Erling Smørgrav {
265b7579f77SDag-Erling Smørgrav 	struct mesh_state* mstate = (struct mesh_state*)n->key;
266b7579f77SDag-Erling Smørgrav 	/* perform a full delete, not only 'cleanup' routine,
267b7579f77SDag-Erling Smørgrav 	 * because other callbacks expect a clean state in the mesh.
268b7579f77SDag-Erling Smørgrav 	 * For 're-entrant' calls */
269b7579f77SDag-Erling Smørgrav 	mesh_state_delete(&mstate->s);
270b7579f77SDag-Erling Smørgrav 	/* but because these delete the items from the tree, postorder
271b7579f77SDag-Erling Smørgrav 	 * traversal and rbtree rebalancing do not work together */
272b7579f77SDag-Erling Smørgrav }
273b7579f77SDag-Erling Smørgrav 
274b7579f77SDag-Erling Smørgrav void
275b7579f77SDag-Erling Smørgrav mesh_delete(struct mesh_area* mesh)
276b7579f77SDag-Erling Smørgrav {
277b7579f77SDag-Erling Smørgrav 	if(!mesh)
278b7579f77SDag-Erling Smørgrav 		return;
279b7579f77SDag-Erling Smørgrav 	/* free all query states */
280b7579f77SDag-Erling Smørgrav 	while(mesh->all.count)
281b7579f77SDag-Erling Smørgrav 		mesh_delete_helper(mesh->all.root);
282b7579f77SDag-Erling Smørgrav 	timehist_delete(mesh->histogram);
28317d15b25SDag-Erling Smørgrav 	sldns_buffer_free(mesh->qbuf_bak);
284b7579f77SDag-Erling Smørgrav 	free(mesh);
285b7579f77SDag-Erling Smørgrav }
286b7579f77SDag-Erling Smørgrav 
287b7579f77SDag-Erling Smørgrav void
288b7579f77SDag-Erling Smørgrav mesh_delete_all(struct mesh_area* mesh)
289b7579f77SDag-Erling Smørgrav {
290b7579f77SDag-Erling Smørgrav 	/* free all query states */
291b7579f77SDag-Erling Smørgrav 	while(mesh->all.count)
292b7579f77SDag-Erling Smørgrav 		mesh_delete_helper(mesh->all.root);
293b7579f77SDag-Erling Smørgrav 	mesh->stats_dropped += mesh->num_reply_addrs;
294b7579f77SDag-Erling Smørgrav 	/* clear mesh area references */
295b7579f77SDag-Erling Smørgrav 	rbtree_init(&mesh->run, &mesh_state_compare);
296b7579f77SDag-Erling Smørgrav 	rbtree_init(&mesh->all, &mesh_state_compare);
297b7579f77SDag-Erling Smørgrav 	mesh->num_reply_addrs = 0;
298b7579f77SDag-Erling Smørgrav 	mesh->num_reply_states = 0;
299b7579f77SDag-Erling Smørgrav 	mesh->num_detached_states = 0;
300b7579f77SDag-Erling Smørgrav 	mesh->num_forever_states = 0;
301b7579f77SDag-Erling Smørgrav 	mesh->forever_first = NULL;
302b7579f77SDag-Erling Smørgrav 	mesh->forever_last = NULL;
303b7579f77SDag-Erling Smørgrav 	mesh->jostle_first = NULL;
304b7579f77SDag-Erling Smørgrav 	mesh->jostle_last = NULL;
305b7579f77SDag-Erling Smørgrav }
306b7579f77SDag-Erling Smørgrav 
30717d15b25SDag-Erling Smørgrav int mesh_make_new_space(struct mesh_area* mesh, sldns_buffer* qbuf)
308b7579f77SDag-Erling Smørgrav {
309b7579f77SDag-Erling Smørgrav 	struct mesh_state* m = mesh->jostle_first;
310b7579f77SDag-Erling Smørgrav 	/* free space is available */
311b7579f77SDag-Erling Smørgrav 	if(mesh->num_reply_states < mesh->max_reply_states)
312b7579f77SDag-Erling Smørgrav 		return 1;
313b7579f77SDag-Erling Smørgrav 	/* try to kick out a jostle-list item */
314b7579f77SDag-Erling Smørgrav 	if(m && m->reply_list && m->list_select == mesh_jostle_list) {
315b7579f77SDag-Erling Smørgrav 		/* how old is it? */
316b7579f77SDag-Erling Smørgrav 		struct timeval age;
317b7579f77SDag-Erling Smørgrav 		timeval_subtract(&age, mesh->env->now_tv,
318b7579f77SDag-Erling Smørgrav 			&m->reply_list->start_time);
319b7579f77SDag-Erling Smørgrav 		if(timeval_smaller(&mesh->jostle_max, &age)) {
320b7579f77SDag-Erling Smørgrav 			/* its a goner */
321b7579f77SDag-Erling Smørgrav 			log_nametypeclass(VERB_ALGO, "query jostled out to "
322b7579f77SDag-Erling Smørgrav 				"make space for a new one",
323b7579f77SDag-Erling Smørgrav 				m->s.qinfo.qname, m->s.qinfo.qtype,
324b7579f77SDag-Erling Smørgrav 				m->s.qinfo.qclass);
325b7579f77SDag-Erling Smørgrav 			/* backup the query */
32617d15b25SDag-Erling Smørgrav 			if(qbuf) sldns_buffer_copy(mesh->qbuf_bak, qbuf);
327b7579f77SDag-Erling Smørgrav 			/* notify supers */
328b7579f77SDag-Erling Smørgrav 			if(m->super_set.count > 0) {
329b7579f77SDag-Erling Smørgrav 				verbose(VERB_ALGO, "notify supers of failure");
330b7579f77SDag-Erling Smørgrav 				m->s.return_msg = NULL;
331b7579f77SDag-Erling Smørgrav 				m->s.return_rcode = LDNS_RCODE_SERVFAIL;
332b7579f77SDag-Erling Smørgrav 				mesh_walk_supers(mesh, m);
333b7579f77SDag-Erling Smørgrav 			}
334b7579f77SDag-Erling Smørgrav 			mesh->stats_jostled ++;
335b7579f77SDag-Erling Smørgrav 			mesh_state_delete(&m->s);
336b7579f77SDag-Erling Smørgrav 			/* restore the query - note that the qinfo ptr to
337b7579f77SDag-Erling Smørgrav 			 * the querybuffer is then correct again. */
33817d15b25SDag-Erling Smørgrav 			if(qbuf) sldns_buffer_copy(qbuf, mesh->qbuf_bak);
339b7579f77SDag-Erling Smørgrav 			return 1;
340b7579f77SDag-Erling Smørgrav 		}
341b7579f77SDag-Erling Smørgrav 	}
342b7579f77SDag-Erling Smørgrav 	/* no space for new item */
343b7579f77SDag-Erling Smørgrav 	return 0;
344b7579f77SDag-Erling Smørgrav }
345b7579f77SDag-Erling Smørgrav 
346b7579f77SDag-Erling Smørgrav void mesh_new_client(struct mesh_area* mesh, struct query_info* qinfo,
34765b390aaSDag-Erling Smørgrav 	struct respip_client_info* cinfo, uint16_t qflags,
34865b390aaSDag-Erling Smørgrav 	struct edns_data* edns, struct comm_reply* rep, uint16_t qid)
349b7579f77SDag-Erling Smørgrav {
350bc892140SDag-Erling Smørgrav 	struct mesh_state* s = NULL;
35165b390aaSDag-Erling Smørgrav 	int unique = unique_mesh_state(edns->opt_list, mesh->env);
352b7579f77SDag-Erling Smørgrav 	int was_detached = 0;
353b7579f77SDag-Erling Smørgrav 	int was_noreply = 0;
354b7579f77SDag-Erling Smørgrav 	int added = 0;
355bc892140SDag-Erling Smørgrav 	if(!unique)
35665b390aaSDag-Erling Smørgrav 		s = mesh_area_find(mesh, cinfo, qinfo, qflags&(BIT_RD|BIT_CD), 0, 0);
357b7579f77SDag-Erling Smørgrav 	/* does this create a new reply state? */
358b7579f77SDag-Erling Smørgrav 	if(!s || s->list_select == mesh_no_list) {
359b7579f77SDag-Erling Smørgrav 		if(!mesh_make_new_space(mesh, rep->c->buffer)) {
360b7579f77SDag-Erling Smørgrav 			verbose(VERB_ALGO, "Too many queries. dropping "
361b7579f77SDag-Erling Smørgrav 				"incoming query.");
362b7579f77SDag-Erling Smørgrav 			comm_point_drop_reply(rep);
363b7579f77SDag-Erling Smørgrav 			mesh->stats_dropped ++;
364b7579f77SDag-Erling Smørgrav 			return;
365b7579f77SDag-Erling Smørgrav 		}
366b7579f77SDag-Erling Smørgrav 		/* for this new reply state, the reply address is free,
367b7579f77SDag-Erling Smørgrav 		 * so the limit of reply addresses does not stop reply states*/
368b7579f77SDag-Erling Smørgrav 	} else {
369b7579f77SDag-Erling Smørgrav 		/* protect our memory usage from storing reply addresses */
370b7579f77SDag-Erling Smørgrav 		if(mesh->num_reply_addrs > mesh->max_reply_states*16) {
371b7579f77SDag-Erling Smørgrav 			verbose(VERB_ALGO, "Too many requests queued. "
372b7579f77SDag-Erling Smørgrav 				"dropping incoming query.");
373b7579f77SDag-Erling Smørgrav 			mesh->stats_dropped++;
374b7579f77SDag-Erling Smørgrav 			comm_point_drop_reply(rep);
375b7579f77SDag-Erling Smørgrav 			return;
376b7579f77SDag-Erling Smørgrav 		}
377b7579f77SDag-Erling Smørgrav 	}
378b7579f77SDag-Erling Smørgrav 	/* see if it already exists, if not, create one */
379b7579f77SDag-Erling Smørgrav 	if(!s) {
380b7579f77SDag-Erling Smørgrav #ifdef UNBOUND_DEBUG
3813005e0a3SDag-Erling Smørgrav 		struct rbnode_type* n;
382b7579f77SDag-Erling Smørgrav #endif
38365b390aaSDag-Erling Smørgrav 		s = mesh_state_create(mesh->env, qinfo, cinfo,
38465b390aaSDag-Erling Smørgrav 			qflags&(BIT_RD|BIT_CD), 0, 0);
385b7579f77SDag-Erling Smørgrav 		if(!s) {
386b7579f77SDag-Erling Smørgrav 			log_err("mesh_state_create: out of memory; SERVFAIL");
387bc892140SDag-Erling Smørgrav 			if(!inplace_cb_reply_servfail_call(mesh->env, qinfo, NULL, NULL,
388bc892140SDag-Erling Smørgrav 				LDNS_RCODE_SERVFAIL, edns, mesh->env->scratch))
389e2d15004SDag-Erling Smørgrav 					edns->opt_list = NULL;
390b7579f77SDag-Erling Smørgrav 			error_encode(rep->c->buffer, LDNS_RCODE_SERVFAIL,
391b7579f77SDag-Erling Smørgrav 				qinfo, qid, qflags, edns);
392b7579f77SDag-Erling Smørgrav 			comm_point_send_reply(rep);
393b7579f77SDag-Erling Smørgrav 			return;
394b7579f77SDag-Erling Smørgrav 		}
395bc892140SDag-Erling Smørgrav 		if(unique)
396bc892140SDag-Erling Smørgrav 			mesh_state_make_unique(s);
397bc892140SDag-Erling Smørgrav 		/* copy the edns options we got from the front */
398bc892140SDag-Erling Smørgrav 		if(edns->opt_list) {
399bc892140SDag-Erling Smørgrav 			s->s.edns_opts_front_in = edns_opt_copy_region(edns->opt_list,
400bc892140SDag-Erling Smørgrav 				s->s.region);
401bc892140SDag-Erling Smørgrav 			if(!s->s.edns_opts_front_in) {
402bc892140SDag-Erling Smørgrav 				log_err("mesh_state_create: out of memory; SERVFAIL");
403bc892140SDag-Erling Smørgrav 				if(!inplace_cb_reply_servfail_call(mesh->env, qinfo, NULL,
404bc892140SDag-Erling Smørgrav 					NULL, LDNS_RCODE_SERVFAIL, edns, mesh->env->scratch))
405bc892140SDag-Erling Smørgrav 						edns->opt_list = NULL;
406bc892140SDag-Erling Smørgrav 				error_encode(rep->c->buffer, LDNS_RCODE_SERVFAIL,
407bc892140SDag-Erling Smørgrav 					qinfo, qid, qflags, edns);
408bc892140SDag-Erling Smørgrav 				comm_point_send_reply(rep);
409bc892140SDag-Erling Smørgrav 				return;
410bc892140SDag-Erling Smørgrav 			}
411bc892140SDag-Erling Smørgrav 		}
412bc892140SDag-Erling Smørgrav 
413b7579f77SDag-Erling Smørgrav #ifdef UNBOUND_DEBUG
414b7579f77SDag-Erling Smørgrav 		n =
41517d15b25SDag-Erling Smørgrav #else
41617d15b25SDag-Erling Smørgrav 		(void)
417b7579f77SDag-Erling Smørgrav #endif
418b7579f77SDag-Erling Smørgrav 		rbtree_insert(&mesh->all, &s->node);
419b7579f77SDag-Erling Smørgrav 		log_assert(n != NULL);
420b7579f77SDag-Erling Smørgrav 		/* set detached (it is now) */
421b7579f77SDag-Erling Smørgrav 		mesh->num_detached_states++;
422b7579f77SDag-Erling Smørgrav 		added = 1;
423b7579f77SDag-Erling Smørgrav 	}
424b7579f77SDag-Erling Smørgrav 	if(!s->reply_list && !s->cb_list && s->super_set.count == 0)
425b7579f77SDag-Erling Smørgrav 		was_detached = 1;
426b7579f77SDag-Erling Smørgrav 	if(!s->reply_list && !s->cb_list)
427b7579f77SDag-Erling Smørgrav 		was_noreply = 1;
428b7579f77SDag-Erling Smørgrav 	/* add reply to s */
429bc892140SDag-Erling Smørgrav 	if(!mesh_state_add_reply(s, edns, rep, qid, qflags, qinfo)) {
430b7579f77SDag-Erling Smørgrav 			log_err("mesh_new_client: out of memory; SERVFAIL");
431bc892140SDag-Erling Smørgrav 			if(!inplace_cb_reply_servfail_call(mesh->env, qinfo, &s->s,
432bc892140SDag-Erling Smørgrav 				NULL, LDNS_RCODE_SERVFAIL, edns, mesh->env->scratch))
433e2d15004SDag-Erling Smørgrav 					edns->opt_list = NULL;
434b7579f77SDag-Erling Smørgrav 			error_encode(rep->c->buffer, LDNS_RCODE_SERVFAIL,
435b7579f77SDag-Erling Smørgrav 				qinfo, qid, qflags, edns);
436b7579f77SDag-Erling Smørgrav 			comm_point_send_reply(rep);
437b7579f77SDag-Erling Smørgrav 			if(added)
438b7579f77SDag-Erling Smørgrav 				mesh_state_delete(&s->s);
439b7579f77SDag-Erling Smørgrav 			return;
440b7579f77SDag-Erling Smørgrav 	}
441b7579f77SDag-Erling Smørgrav 	/* update statistics */
442b7579f77SDag-Erling Smørgrav 	if(was_detached) {
443b7579f77SDag-Erling Smørgrav 		log_assert(mesh->num_detached_states > 0);
444b7579f77SDag-Erling Smørgrav 		mesh->num_detached_states--;
445b7579f77SDag-Erling Smørgrav 	}
446b7579f77SDag-Erling Smørgrav 	if(was_noreply) {
447b7579f77SDag-Erling Smørgrav 		mesh->num_reply_states ++;
448b7579f77SDag-Erling Smørgrav 	}
449b7579f77SDag-Erling Smørgrav 	mesh->num_reply_addrs++;
450b7579f77SDag-Erling Smørgrav 	if(s->list_select == mesh_no_list) {
451b7579f77SDag-Erling Smørgrav 		/* move to either the forever or the jostle_list */
452b7579f77SDag-Erling Smørgrav 		if(mesh->num_forever_states < mesh->max_forever_states) {
453b7579f77SDag-Erling Smørgrav 			mesh->num_forever_states ++;
454b7579f77SDag-Erling Smørgrav 			mesh_list_insert(s, &mesh->forever_first,
455b7579f77SDag-Erling Smørgrav 				&mesh->forever_last);
456b7579f77SDag-Erling Smørgrav 			s->list_select = mesh_forever_list;
457b7579f77SDag-Erling Smørgrav 		} else {
458b7579f77SDag-Erling Smørgrav 			mesh_list_insert(s, &mesh->jostle_first,
459b7579f77SDag-Erling Smørgrav 				&mesh->jostle_last);
460b7579f77SDag-Erling Smørgrav 			s->list_select = mesh_jostle_list;
461b7579f77SDag-Erling Smørgrav 		}
462b7579f77SDag-Erling Smørgrav 	}
463b7579f77SDag-Erling Smørgrav 	if(added)
464b7579f77SDag-Erling Smørgrav 		mesh_run(mesh, s, module_event_new, NULL);
465b7579f77SDag-Erling Smørgrav }
466b7579f77SDag-Erling Smørgrav 
467b7579f77SDag-Erling Smørgrav int
468b7579f77SDag-Erling Smørgrav mesh_new_callback(struct mesh_area* mesh, struct query_info* qinfo,
46917d15b25SDag-Erling Smørgrav 	uint16_t qflags, struct edns_data* edns, sldns_buffer* buf,
4703005e0a3SDag-Erling Smørgrav 	uint16_t qid, mesh_cb_func_type cb, void* cb_arg)
471b7579f77SDag-Erling Smørgrav {
472bc892140SDag-Erling Smørgrav 	struct mesh_state* s = NULL;
47365b390aaSDag-Erling Smørgrav 	int unique = unique_mesh_state(edns->opt_list, mesh->env);
474b7579f77SDag-Erling Smørgrav 	int was_detached = 0;
475b7579f77SDag-Erling Smørgrav 	int was_noreply = 0;
476b7579f77SDag-Erling Smørgrav 	int added = 0;
477bc892140SDag-Erling Smørgrav 	if(!unique)
47865b390aaSDag-Erling Smørgrav 		s = mesh_area_find(mesh, NULL, qinfo, qflags&(BIT_RD|BIT_CD), 0, 0);
47965b390aaSDag-Erling Smørgrav 
480b7579f77SDag-Erling Smørgrav 	/* there are no limits on the number of callbacks */
481b7579f77SDag-Erling Smørgrav 
482b7579f77SDag-Erling Smørgrav 	/* see if it already exists, if not, create one */
483b7579f77SDag-Erling Smørgrav 	if(!s) {
484b7579f77SDag-Erling Smørgrav #ifdef UNBOUND_DEBUG
4853005e0a3SDag-Erling Smørgrav 		struct rbnode_type* n;
486b7579f77SDag-Erling Smørgrav #endif
48765b390aaSDag-Erling Smørgrav 		s = mesh_state_create(mesh->env, qinfo, NULL,
48865b390aaSDag-Erling Smørgrav 			qflags&(BIT_RD|BIT_CD), 0, 0);
489b7579f77SDag-Erling Smørgrav 		if(!s) {
490b7579f77SDag-Erling Smørgrav 			return 0;
491b7579f77SDag-Erling Smørgrav 		}
492bc892140SDag-Erling Smørgrav 		if(unique)
493bc892140SDag-Erling Smørgrav 			mesh_state_make_unique(s);
494bc892140SDag-Erling Smørgrav 		if(edns->opt_list) {
495bc892140SDag-Erling Smørgrav 			s->s.edns_opts_front_in = edns_opt_copy_region(edns->opt_list,
496bc892140SDag-Erling Smørgrav 				s->s.region);
497bc892140SDag-Erling Smørgrav 			if(!s->s.edns_opts_front_in) {
498bc892140SDag-Erling Smørgrav 				return 0;
499bc892140SDag-Erling Smørgrav 			}
500bc892140SDag-Erling Smørgrav 		}
501b7579f77SDag-Erling Smørgrav #ifdef UNBOUND_DEBUG
502b7579f77SDag-Erling Smørgrav 		n =
50317d15b25SDag-Erling Smørgrav #else
50417d15b25SDag-Erling Smørgrav 		(void)
505b7579f77SDag-Erling Smørgrav #endif
506b7579f77SDag-Erling Smørgrav 		rbtree_insert(&mesh->all, &s->node);
507b7579f77SDag-Erling Smørgrav 		log_assert(n != NULL);
508b7579f77SDag-Erling Smørgrav 		/* set detached (it is now) */
509b7579f77SDag-Erling Smørgrav 		mesh->num_detached_states++;
510b7579f77SDag-Erling Smørgrav 		added = 1;
511b7579f77SDag-Erling Smørgrav 	}
512b7579f77SDag-Erling Smørgrav 	if(!s->reply_list && !s->cb_list && s->super_set.count == 0)
513b7579f77SDag-Erling Smørgrav 		was_detached = 1;
514b7579f77SDag-Erling Smørgrav 	if(!s->reply_list && !s->cb_list)
515b7579f77SDag-Erling Smørgrav 		was_noreply = 1;
516b7579f77SDag-Erling Smørgrav 	/* add reply to s */
517b7579f77SDag-Erling Smørgrav 	if(!mesh_state_add_cb(s, edns, buf, cb, cb_arg, qid, qflags)) {
518b7579f77SDag-Erling Smørgrav 			if(added)
519b7579f77SDag-Erling Smørgrav 				mesh_state_delete(&s->s);
520b7579f77SDag-Erling Smørgrav 			return 0;
521b7579f77SDag-Erling Smørgrav 	}
522b7579f77SDag-Erling Smørgrav 	/* update statistics */
523b7579f77SDag-Erling Smørgrav 	if(was_detached) {
524b7579f77SDag-Erling Smørgrav 		log_assert(mesh->num_detached_states > 0);
525b7579f77SDag-Erling Smørgrav 		mesh->num_detached_states--;
526b7579f77SDag-Erling Smørgrav 	}
527b7579f77SDag-Erling Smørgrav 	if(was_noreply) {
528b7579f77SDag-Erling Smørgrav 		mesh->num_reply_states ++;
529b7579f77SDag-Erling Smørgrav 	}
530b7579f77SDag-Erling Smørgrav 	mesh->num_reply_addrs++;
531b7579f77SDag-Erling Smørgrav 	if(added)
532b7579f77SDag-Erling Smørgrav 		mesh_run(mesh, s, module_event_new, NULL);
533b7579f77SDag-Erling Smørgrav 	return 1;
534b7579f77SDag-Erling Smørgrav }
535b7579f77SDag-Erling Smørgrav 
536*8a384985SDag-Erling Smørgrav static void mesh_schedule_prefetch(struct mesh_area* mesh,
537*8a384985SDag-Erling Smørgrav 	struct query_info* qinfo, uint16_t qflags, time_t leeway, int run);
538*8a384985SDag-Erling Smørgrav 
539b7579f77SDag-Erling Smørgrav void mesh_new_prefetch(struct mesh_area* mesh, struct query_info* qinfo,
54017d15b25SDag-Erling Smørgrav         uint16_t qflags, time_t leeway)
541b7579f77SDag-Erling Smørgrav {
542*8a384985SDag-Erling Smørgrav 	mesh_schedule_prefetch(mesh, qinfo, qflags, leeway, 1);
543*8a384985SDag-Erling Smørgrav }
544*8a384985SDag-Erling Smørgrav 
545*8a384985SDag-Erling Smørgrav /* Internal backend routine of mesh_new_prefetch().  It takes one additional
546*8a384985SDag-Erling Smørgrav  * parameter, 'run', which controls whether to run the prefetch state
547*8a384985SDag-Erling Smørgrav  * immediately.  When this function is called internally 'run' could be
548*8a384985SDag-Erling Smørgrav  * 0 (false), in which case the new state is only made runnable so it
549*8a384985SDag-Erling Smørgrav  * will not be run recursively on top of the current state. */
550*8a384985SDag-Erling Smørgrav static void mesh_schedule_prefetch(struct mesh_area* mesh,
551*8a384985SDag-Erling Smørgrav 	struct query_info* qinfo, uint16_t qflags, time_t leeway, int run)
552*8a384985SDag-Erling Smørgrav {
55365b390aaSDag-Erling Smørgrav 	struct mesh_state* s = mesh_area_find(mesh, NULL, qinfo,
55465b390aaSDag-Erling Smørgrav 		qflags&(BIT_RD|BIT_CD), 0, 0);
555b7579f77SDag-Erling Smørgrav #ifdef UNBOUND_DEBUG
5563005e0a3SDag-Erling Smørgrav 	struct rbnode_type* n;
557b7579f77SDag-Erling Smørgrav #endif
558b7579f77SDag-Erling Smørgrav 	/* already exists, and for a different purpose perhaps.
559b7579f77SDag-Erling Smørgrav 	 * if mesh_no_list, keep it that way. */
560b7579f77SDag-Erling Smørgrav 	if(s) {
561b7579f77SDag-Erling Smørgrav 		/* make it ignore the cache from now on */
562b7579f77SDag-Erling Smørgrav 		if(!s->s.blacklist)
563b7579f77SDag-Erling Smørgrav 			sock_list_insert(&s->s.blacklist, NULL, 0, s->s.region);
564b7579f77SDag-Erling Smørgrav 		if(s->s.prefetch_leeway < leeway)
565b7579f77SDag-Erling Smørgrav 			s->s.prefetch_leeway = leeway;
566b7579f77SDag-Erling Smørgrav 		return;
567b7579f77SDag-Erling Smørgrav 	}
568b7579f77SDag-Erling Smørgrav 	if(!mesh_make_new_space(mesh, NULL)) {
569b7579f77SDag-Erling Smørgrav 		verbose(VERB_ALGO, "Too many queries. dropped prefetch.");
570b7579f77SDag-Erling Smørgrav 		mesh->stats_dropped ++;
571b7579f77SDag-Erling Smørgrav 		return;
572b7579f77SDag-Erling Smørgrav 	}
573bc892140SDag-Erling Smørgrav 
57465b390aaSDag-Erling Smørgrav 	s = mesh_state_create(mesh->env, qinfo, NULL,
57565b390aaSDag-Erling Smørgrav 		qflags&(BIT_RD|BIT_CD), 0, 0);
576b7579f77SDag-Erling Smørgrav 	if(!s) {
577b7579f77SDag-Erling Smørgrav 		log_err("prefetch mesh_state_create: out of memory");
578b7579f77SDag-Erling Smørgrav 		return;
579b7579f77SDag-Erling Smørgrav 	}
580b7579f77SDag-Erling Smørgrav #ifdef UNBOUND_DEBUG
581b7579f77SDag-Erling Smørgrav 	n =
58217d15b25SDag-Erling Smørgrav #else
58317d15b25SDag-Erling Smørgrav 	(void)
584b7579f77SDag-Erling Smørgrav #endif
585b7579f77SDag-Erling Smørgrav 	rbtree_insert(&mesh->all, &s->node);
586b7579f77SDag-Erling Smørgrav 	log_assert(n != NULL);
587b7579f77SDag-Erling Smørgrav 	/* set detached (it is now) */
588b7579f77SDag-Erling Smørgrav 	mesh->num_detached_states++;
589b7579f77SDag-Erling Smørgrav 	/* make it ignore the cache */
590b7579f77SDag-Erling Smørgrav 	sock_list_insert(&s->s.blacklist, NULL, 0, s->s.region);
591b7579f77SDag-Erling Smørgrav 	s->s.prefetch_leeway = leeway;
592b7579f77SDag-Erling Smørgrav 
593b7579f77SDag-Erling Smørgrav 	if(s->list_select == mesh_no_list) {
594b7579f77SDag-Erling Smørgrav 		/* move to either the forever or the jostle_list */
595b7579f77SDag-Erling Smørgrav 		if(mesh->num_forever_states < mesh->max_forever_states) {
596b7579f77SDag-Erling Smørgrav 			mesh->num_forever_states ++;
597b7579f77SDag-Erling Smørgrav 			mesh_list_insert(s, &mesh->forever_first,
598b7579f77SDag-Erling Smørgrav 				&mesh->forever_last);
599b7579f77SDag-Erling Smørgrav 			s->list_select = mesh_forever_list;
600b7579f77SDag-Erling Smørgrav 		} else {
601b7579f77SDag-Erling Smørgrav 			mesh_list_insert(s, &mesh->jostle_first,
602b7579f77SDag-Erling Smørgrav 				&mesh->jostle_last);
603b7579f77SDag-Erling Smørgrav 			s->list_select = mesh_jostle_list;
604b7579f77SDag-Erling Smørgrav 		}
605b7579f77SDag-Erling Smørgrav 	}
606*8a384985SDag-Erling Smørgrav 
607*8a384985SDag-Erling Smørgrav 	if(!run) {
608*8a384985SDag-Erling Smørgrav #ifdef UNBOUND_DEBUG
609*8a384985SDag-Erling Smørgrav 		n =
610*8a384985SDag-Erling Smørgrav #else
611*8a384985SDag-Erling Smørgrav 		(void)
612*8a384985SDag-Erling Smørgrav #endif
613*8a384985SDag-Erling Smørgrav 		rbtree_insert(&mesh->run, &s->run_node);
614*8a384985SDag-Erling Smørgrav 		log_assert(n != NULL);
615*8a384985SDag-Erling Smørgrav 		return;
616*8a384985SDag-Erling Smørgrav 	}
617*8a384985SDag-Erling Smørgrav 
618b7579f77SDag-Erling Smørgrav 	mesh_run(mesh, s, module_event_new, NULL);
619b7579f77SDag-Erling Smørgrav }
620b7579f77SDag-Erling Smørgrav 
621b7579f77SDag-Erling Smørgrav void mesh_report_reply(struct mesh_area* mesh, struct outbound_entry* e,
622b7579f77SDag-Erling Smørgrav         struct comm_reply* reply, int what)
623b7579f77SDag-Erling Smørgrav {
624b7579f77SDag-Erling Smørgrav 	enum module_ev event = module_event_reply;
625b7579f77SDag-Erling Smørgrav 	e->qstate->reply = reply;
626b7579f77SDag-Erling Smørgrav 	if(what != NETEVENT_NOERROR) {
627b7579f77SDag-Erling Smørgrav 		event = module_event_noreply;
628b7579f77SDag-Erling Smørgrav 		if(what == NETEVENT_CAPSFAIL)
629b7579f77SDag-Erling Smørgrav 			event = module_event_capsfail;
630b7579f77SDag-Erling Smørgrav 	}
631b7579f77SDag-Erling Smørgrav 	mesh_run(mesh, e->qstate->mesh_info, event, e);
632b7579f77SDag-Erling Smørgrav }
633b7579f77SDag-Erling Smørgrav 
634b7579f77SDag-Erling Smørgrav struct mesh_state*
635b7579f77SDag-Erling Smørgrav mesh_state_create(struct module_env* env, struct query_info* qinfo,
63665b390aaSDag-Erling Smørgrav 	struct respip_client_info* cinfo, uint16_t qflags, int prime,
63765b390aaSDag-Erling Smørgrav 	int valrec)
638b7579f77SDag-Erling Smørgrav {
639b7579f77SDag-Erling Smørgrav 	struct regional* region = alloc_reg_obtain(env->alloc);
640b7579f77SDag-Erling Smørgrav 	struct mesh_state* mstate;
641b7579f77SDag-Erling Smørgrav 	int i;
642b7579f77SDag-Erling Smørgrav 	if(!region)
643b7579f77SDag-Erling Smørgrav 		return NULL;
644b7579f77SDag-Erling Smørgrav 	mstate = (struct mesh_state*)regional_alloc(region,
645b7579f77SDag-Erling Smørgrav 		sizeof(struct mesh_state));
646b7579f77SDag-Erling Smørgrav 	if(!mstate) {
647b7579f77SDag-Erling Smørgrav 		alloc_reg_release(env->alloc, region);
648b7579f77SDag-Erling Smørgrav 		return NULL;
649b7579f77SDag-Erling Smørgrav 	}
650b7579f77SDag-Erling Smørgrav 	memset(mstate, 0, sizeof(*mstate));
651b7579f77SDag-Erling Smørgrav 	mstate->node = *RBTREE_NULL;
652b7579f77SDag-Erling Smørgrav 	mstate->run_node = *RBTREE_NULL;
653b7579f77SDag-Erling Smørgrav 	mstate->node.key = mstate;
654b7579f77SDag-Erling Smørgrav 	mstate->run_node.key = mstate;
655b7579f77SDag-Erling Smørgrav 	mstate->reply_list = NULL;
656b7579f77SDag-Erling Smørgrav 	mstate->list_select = mesh_no_list;
657b7579f77SDag-Erling Smørgrav 	mstate->replies_sent = 0;
658b7579f77SDag-Erling Smørgrav 	rbtree_init(&mstate->super_set, &mesh_state_ref_compare);
659b7579f77SDag-Erling Smørgrav 	rbtree_init(&mstate->sub_set, &mesh_state_ref_compare);
660b7579f77SDag-Erling Smørgrav 	mstate->num_activated = 0;
661bc892140SDag-Erling Smørgrav 	mstate->unique = NULL;
662b7579f77SDag-Erling Smørgrav 	/* init module qstate */
663b7579f77SDag-Erling Smørgrav 	mstate->s.qinfo.qtype = qinfo->qtype;
664b7579f77SDag-Erling Smørgrav 	mstate->s.qinfo.qclass = qinfo->qclass;
665bc892140SDag-Erling Smørgrav 	mstate->s.qinfo.local_alias = NULL;
666b7579f77SDag-Erling Smørgrav 	mstate->s.qinfo.qname_len = qinfo->qname_len;
667b7579f77SDag-Erling Smørgrav 	mstate->s.qinfo.qname = regional_alloc_init(region, qinfo->qname,
668b7579f77SDag-Erling Smørgrav 		qinfo->qname_len);
669b7579f77SDag-Erling Smørgrav 	if(!mstate->s.qinfo.qname) {
670b7579f77SDag-Erling Smørgrav 		alloc_reg_release(env->alloc, region);
671b7579f77SDag-Erling Smørgrav 		return NULL;
672b7579f77SDag-Erling Smørgrav 	}
67365b390aaSDag-Erling Smørgrav 	if(cinfo) {
67465b390aaSDag-Erling Smørgrav 		mstate->s.client_info = regional_alloc_init(region, cinfo,
67565b390aaSDag-Erling Smørgrav 			sizeof(*cinfo));
67665b390aaSDag-Erling Smørgrav 		if(!mstate->s.client_info) {
67765b390aaSDag-Erling Smørgrav 			alloc_reg_release(env->alloc, region);
67865b390aaSDag-Erling Smørgrav 			return NULL;
67965b390aaSDag-Erling Smørgrav 		}
68065b390aaSDag-Erling Smørgrav 	}
681b7579f77SDag-Erling Smørgrav 	/* remove all weird bits from qflags */
682b7579f77SDag-Erling Smørgrav 	mstate->s.query_flags = (qflags & (BIT_RD|BIT_CD));
683b7579f77SDag-Erling Smørgrav 	mstate->s.is_priming = prime;
684ff825849SDag-Erling Smørgrav 	mstate->s.is_valrec = valrec;
685b7579f77SDag-Erling Smørgrav 	mstate->s.reply = NULL;
686b7579f77SDag-Erling Smørgrav 	mstate->s.region = region;
687b7579f77SDag-Erling Smørgrav 	mstate->s.curmod = 0;
688b7579f77SDag-Erling Smørgrav 	mstate->s.return_msg = 0;
689b7579f77SDag-Erling Smørgrav 	mstate->s.return_rcode = LDNS_RCODE_NOERROR;
690b7579f77SDag-Erling Smørgrav 	mstate->s.env = env;
691b7579f77SDag-Erling Smørgrav 	mstate->s.mesh_info = mstate;
692b7579f77SDag-Erling Smørgrav 	mstate->s.prefetch_leeway = 0;
693bc892140SDag-Erling Smørgrav 	mstate->s.no_cache_lookup = 0;
694bc892140SDag-Erling Smørgrav 	mstate->s.no_cache_store = 0;
695*8a384985SDag-Erling Smørgrav 	mstate->s.need_refetch = 0;
696*8a384985SDag-Erling Smørgrav 
697b7579f77SDag-Erling Smørgrav 	/* init modules */
698b7579f77SDag-Erling Smørgrav 	for(i=0; i<env->mesh->mods.num; i++) {
699b7579f77SDag-Erling Smørgrav 		mstate->s.minfo[i] = NULL;
700b7579f77SDag-Erling Smørgrav 		mstate->s.ext_state[i] = module_state_initial;
701b7579f77SDag-Erling Smørgrav 	}
702bc892140SDag-Erling Smørgrav 	/* init edns option lists */
703bc892140SDag-Erling Smørgrav 	mstate->s.edns_opts_front_in = NULL;
704bc892140SDag-Erling Smørgrav 	mstate->s.edns_opts_back_out = NULL;
705bc892140SDag-Erling Smørgrav 	mstate->s.edns_opts_back_in = NULL;
706bc892140SDag-Erling Smørgrav 	mstate->s.edns_opts_front_out = NULL;
707bc892140SDag-Erling Smørgrav 
708b7579f77SDag-Erling Smørgrav 	return mstate;
709b7579f77SDag-Erling Smørgrav }
710b7579f77SDag-Erling Smørgrav 
711bc892140SDag-Erling Smørgrav int
712bc892140SDag-Erling Smørgrav mesh_state_is_unique(struct mesh_state* mstate)
713bc892140SDag-Erling Smørgrav {
714bc892140SDag-Erling Smørgrav 	return mstate->unique != NULL;
715bc892140SDag-Erling Smørgrav }
716bc892140SDag-Erling Smørgrav 
717bc892140SDag-Erling Smørgrav void
718bc892140SDag-Erling Smørgrav mesh_state_make_unique(struct mesh_state* mstate)
719bc892140SDag-Erling Smørgrav {
720bc892140SDag-Erling Smørgrav 	mstate->unique = mstate;
721bc892140SDag-Erling Smørgrav }
722bc892140SDag-Erling Smørgrav 
723b7579f77SDag-Erling Smørgrav void
724b7579f77SDag-Erling Smørgrav mesh_state_cleanup(struct mesh_state* mstate)
725b7579f77SDag-Erling Smørgrav {
726b7579f77SDag-Erling Smørgrav 	struct mesh_area* mesh;
727b7579f77SDag-Erling Smørgrav 	int i;
728b7579f77SDag-Erling Smørgrav 	if(!mstate)
729b7579f77SDag-Erling Smørgrav 		return;
730b7579f77SDag-Erling Smørgrav 	mesh = mstate->s.env->mesh;
731b7579f77SDag-Erling Smørgrav 	/* drop unsent replies */
732b7579f77SDag-Erling Smørgrav 	if(!mstate->replies_sent) {
733b7579f77SDag-Erling Smørgrav 		struct mesh_reply* rep;
734b7579f77SDag-Erling Smørgrav 		struct mesh_cb* cb;
735b7579f77SDag-Erling Smørgrav 		for(rep=mstate->reply_list; rep; rep=rep->next) {
736b7579f77SDag-Erling Smørgrav 			comm_point_drop_reply(&rep->query_reply);
737b7579f77SDag-Erling Smørgrav 			mesh->num_reply_addrs--;
738b7579f77SDag-Erling Smørgrav 		}
739b7579f77SDag-Erling Smørgrav 		for(cb=mstate->cb_list; cb; cb=cb->next) {
740b7579f77SDag-Erling Smørgrav 			fptr_ok(fptr_whitelist_mesh_cb(cb->cb));
741b7579f77SDag-Erling Smørgrav 			(*cb->cb)(cb->cb_arg, LDNS_RCODE_SERVFAIL, NULL,
742b7579f77SDag-Erling Smørgrav 				sec_status_unchecked, NULL);
743b7579f77SDag-Erling Smørgrav 			mesh->num_reply_addrs--;
744b7579f77SDag-Erling Smørgrav 		}
745b7579f77SDag-Erling Smørgrav 	}
746b7579f77SDag-Erling Smørgrav 
747b7579f77SDag-Erling Smørgrav 	/* de-init modules */
748b7579f77SDag-Erling Smørgrav 	for(i=0; i<mesh->mods.num; i++) {
749b7579f77SDag-Erling Smørgrav 		fptr_ok(fptr_whitelist_mod_clear(mesh->mods.mod[i]->clear));
750b7579f77SDag-Erling Smørgrav 		(*mesh->mods.mod[i]->clear)(&mstate->s, i);
751b7579f77SDag-Erling Smørgrav 		mstate->s.minfo[i] = NULL;
752b7579f77SDag-Erling Smørgrav 		mstate->s.ext_state[i] = module_finished;
753b7579f77SDag-Erling Smørgrav 	}
754b7579f77SDag-Erling Smørgrav 	alloc_reg_release(mstate->s.env->alloc, mstate->s.region);
755b7579f77SDag-Erling Smørgrav }
756b7579f77SDag-Erling Smørgrav 
757b7579f77SDag-Erling Smørgrav void
758b7579f77SDag-Erling Smørgrav mesh_state_delete(struct module_qstate* qstate)
759b7579f77SDag-Erling Smørgrav {
760b7579f77SDag-Erling Smørgrav 	struct mesh_area* mesh;
761b7579f77SDag-Erling Smørgrav 	struct mesh_state_ref* super, ref;
762b7579f77SDag-Erling Smørgrav 	struct mesh_state* mstate;
763b7579f77SDag-Erling Smørgrav 	if(!qstate)
764b7579f77SDag-Erling Smørgrav 		return;
765b7579f77SDag-Erling Smørgrav 	mstate = qstate->mesh_info;
766b7579f77SDag-Erling Smørgrav 	mesh = mstate->s.env->mesh;
767b7579f77SDag-Erling Smørgrav 	mesh_detach_subs(&mstate->s);
768b7579f77SDag-Erling Smørgrav 	if(mstate->list_select == mesh_forever_list) {
769b7579f77SDag-Erling Smørgrav 		mesh->num_forever_states --;
770b7579f77SDag-Erling Smørgrav 		mesh_list_remove(mstate, &mesh->forever_first,
771b7579f77SDag-Erling Smørgrav 			&mesh->forever_last);
772b7579f77SDag-Erling Smørgrav 	} else if(mstate->list_select == mesh_jostle_list) {
773b7579f77SDag-Erling Smørgrav 		mesh_list_remove(mstate, &mesh->jostle_first,
774b7579f77SDag-Erling Smørgrav 			&mesh->jostle_last);
775b7579f77SDag-Erling Smørgrav 	}
776b7579f77SDag-Erling Smørgrav 	if(!mstate->reply_list && !mstate->cb_list
777b7579f77SDag-Erling Smørgrav 		&& mstate->super_set.count == 0) {
778b7579f77SDag-Erling Smørgrav 		log_assert(mesh->num_detached_states > 0);
779b7579f77SDag-Erling Smørgrav 		mesh->num_detached_states--;
780b7579f77SDag-Erling Smørgrav 	}
781b7579f77SDag-Erling Smørgrav 	if(mstate->reply_list || mstate->cb_list) {
782b7579f77SDag-Erling Smørgrav 		log_assert(mesh->num_reply_states > 0);
783b7579f77SDag-Erling Smørgrav 		mesh->num_reply_states--;
784b7579f77SDag-Erling Smørgrav 	}
785b7579f77SDag-Erling Smørgrav 	ref.node.key = &ref;
786b7579f77SDag-Erling Smørgrav 	ref.s = mstate;
787b7579f77SDag-Erling Smørgrav 	RBTREE_FOR(super, struct mesh_state_ref*, &mstate->super_set) {
788b7579f77SDag-Erling Smørgrav 		(void)rbtree_delete(&super->s->sub_set, &ref);
789b7579f77SDag-Erling Smørgrav 	}
790b7579f77SDag-Erling Smørgrav 	(void)rbtree_delete(&mesh->run, mstate);
791b7579f77SDag-Erling Smørgrav 	(void)rbtree_delete(&mesh->all, mstate);
792b7579f77SDag-Erling Smørgrav 	mesh_state_cleanup(mstate);
793b7579f77SDag-Erling Smørgrav }
794b7579f77SDag-Erling Smørgrav 
795b7579f77SDag-Erling Smørgrav /** helper recursive rbtree find routine */
796b7579f77SDag-Erling Smørgrav static int
797b7579f77SDag-Erling Smørgrav find_in_subsub(struct mesh_state* m, struct mesh_state* tofind, size_t *c)
798b7579f77SDag-Erling Smørgrav {
799b7579f77SDag-Erling Smørgrav 	struct mesh_state_ref* r;
800b7579f77SDag-Erling Smørgrav 	if((*c)++ > MESH_MAX_SUBSUB)
801b7579f77SDag-Erling Smørgrav 		return 1;
802b7579f77SDag-Erling Smørgrav 	RBTREE_FOR(r, struct mesh_state_ref*, &m->sub_set) {
803b7579f77SDag-Erling Smørgrav 		if(r->s == tofind || find_in_subsub(r->s, tofind, c))
804b7579f77SDag-Erling Smørgrav 			return 1;
805b7579f77SDag-Erling Smørgrav 	}
806b7579f77SDag-Erling Smørgrav 	return 0;
807b7579f77SDag-Erling Smørgrav }
808b7579f77SDag-Erling Smørgrav 
809b7579f77SDag-Erling Smørgrav /** find cycle for already looked up mesh_state */
810b7579f77SDag-Erling Smørgrav static int
811b7579f77SDag-Erling Smørgrav mesh_detect_cycle_found(struct module_qstate* qstate, struct mesh_state* dep_m)
812b7579f77SDag-Erling Smørgrav {
813b7579f77SDag-Erling Smørgrav 	struct mesh_state* cyc_m = qstate->mesh_info;
814b7579f77SDag-Erling Smørgrav 	size_t counter = 0;
815b7579f77SDag-Erling Smørgrav 	if(!dep_m)
816b7579f77SDag-Erling Smørgrav 		return 0;
817b7579f77SDag-Erling Smørgrav 	if(dep_m == cyc_m || find_in_subsub(dep_m, cyc_m, &counter)) {
818b7579f77SDag-Erling Smørgrav 		if(counter > MESH_MAX_SUBSUB)
819b7579f77SDag-Erling Smørgrav 			return 2;
820b7579f77SDag-Erling Smørgrav 		return 1;
821b7579f77SDag-Erling Smørgrav 	}
822b7579f77SDag-Erling Smørgrav 	return 0;
823b7579f77SDag-Erling Smørgrav }
824b7579f77SDag-Erling Smørgrav 
825b7579f77SDag-Erling Smørgrav void mesh_detach_subs(struct module_qstate* qstate)
826b7579f77SDag-Erling Smørgrav {
827b7579f77SDag-Erling Smørgrav 	struct mesh_area* mesh = qstate->env->mesh;
828b7579f77SDag-Erling Smørgrav 	struct mesh_state_ref* ref, lookup;
829b7579f77SDag-Erling Smørgrav #ifdef UNBOUND_DEBUG
8303005e0a3SDag-Erling Smørgrav 	struct rbnode_type* n;
831b7579f77SDag-Erling Smørgrav #endif
832b7579f77SDag-Erling Smørgrav 	lookup.node.key = &lookup;
833b7579f77SDag-Erling Smørgrav 	lookup.s = qstate->mesh_info;
834b7579f77SDag-Erling Smørgrav 	RBTREE_FOR(ref, struct mesh_state_ref*, &qstate->mesh_info->sub_set) {
835b7579f77SDag-Erling Smørgrav #ifdef UNBOUND_DEBUG
836b7579f77SDag-Erling Smørgrav 		n =
83717d15b25SDag-Erling Smørgrav #else
83817d15b25SDag-Erling Smørgrav 		(void)
839b7579f77SDag-Erling Smørgrav #endif
840b7579f77SDag-Erling Smørgrav 		rbtree_delete(&ref->s->super_set, &lookup);
841b7579f77SDag-Erling Smørgrav 		log_assert(n != NULL); /* must have been present */
842b7579f77SDag-Erling Smørgrav 		if(!ref->s->reply_list && !ref->s->cb_list
843b7579f77SDag-Erling Smørgrav 			&& ref->s->super_set.count == 0) {
844b7579f77SDag-Erling Smørgrav 			mesh->num_detached_states++;
845b7579f77SDag-Erling Smørgrav 			log_assert(mesh->num_detached_states +
846b7579f77SDag-Erling Smørgrav 				mesh->num_reply_states <= mesh->all.count);
847b7579f77SDag-Erling Smørgrav 		}
848b7579f77SDag-Erling Smørgrav 	}
849b7579f77SDag-Erling Smørgrav 	rbtree_init(&qstate->mesh_info->sub_set, &mesh_state_ref_compare);
850b7579f77SDag-Erling Smørgrav }
851b7579f77SDag-Erling Smørgrav 
852c7f4d7adSDag-Erling Smørgrav int mesh_add_sub(struct module_qstate* qstate, struct query_info* qinfo,
853c7f4d7adSDag-Erling Smørgrav         uint16_t qflags, int prime, int valrec, struct module_qstate** newq,
854c7f4d7adSDag-Erling Smørgrav 	struct mesh_state** sub)
855b7579f77SDag-Erling Smørgrav {
856b7579f77SDag-Erling Smørgrav 	/* find it, if not, create it */
857b7579f77SDag-Erling Smørgrav 	struct mesh_area* mesh = qstate->env->mesh;
858c7f4d7adSDag-Erling Smørgrav 	*sub = mesh_area_find(mesh, NULL, qinfo, qflags,
85965b390aaSDag-Erling Smørgrav 		prime, valrec);
860c7f4d7adSDag-Erling Smørgrav 	if(mesh_detect_cycle_found(qstate, *sub)) {
861b7579f77SDag-Erling Smørgrav 		verbose(VERB_ALGO, "attach failed, cycle detected");
862b7579f77SDag-Erling Smørgrav 		return 0;
863b7579f77SDag-Erling Smørgrav 	}
864c7f4d7adSDag-Erling Smørgrav 	if(!*sub) {
865b7579f77SDag-Erling Smørgrav #ifdef UNBOUND_DEBUG
8663005e0a3SDag-Erling Smørgrav 		struct rbnode_type* n;
867b7579f77SDag-Erling Smørgrav #endif
868b7579f77SDag-Erling Smørgrav 		/* create a new one */
869c7f4d7adSDag-Erling Smørgrav 		*sub = mesh_state_create(qstate->env, qinfo, NULL, qflags, prime,
87065b390aaSDag-Erling Smørgrav 			valrec);
871c7f4d7adSDag-Erling Smørgrav 		if(!*sub) {
872b7579f77SDag-Erling Smørgrav 			log_err("mesh_attach_sub: out of memory");
873b7579f77SDag-Erling Smørgrav 			return 0;
874b7579f77SDag-Erling Smørgrav 		}
875b7579f77SDag-Erling Smørgrav #ifdef UNBOUND_DEBUG
876b7579f77SDag-Erling Smørgrav 		n =
87717d15b25SDag-Erling Smørgrav #else
87817d15b25SDag-Erling Smørgrav 		(void)
879b7579f77SDag-Erling Smørgrav #endif
880c7f4d7adSDag-Erling Smørgrav 		rbtree_insert(&mesh->all, &(*sub)->node);
881b7579f77SDag-Erling Smørgrav 		log_assert(n != NULL);
882b7579f77SDag-Erling Smørgrav 		/* set detached (it is now) */
883b7579f77SDag-Erling Smørgrav 		mesh->num_detached_states++;
884b7579f77SDag-Erling Smørgrav 		/* set new query state to run */
885b7579f77SDag-Erling Smørgrav #ifdef UNBOUND_DEBUG
886b7579f77SDag-Erling Smørgrav 		n =
88717d15b25SDag-Erling Smørgrav #else
88817d15b25SDag-Erling Smørgrav 		(void)
889b7579f77SDag-Erling Smørgrav #endif
890c7f4d7adSDag-Erling Smørgrav 		rbtree_insert(&mesh->run, &(*sub)->run_node);
891b7579f77SDag-Erling Smørgrav 		log_assert(n != NULL);
892c7f4d7adSDag-Erling Smørgrav 		*newq = &(*sub)->s;
893b7579f77SDag-Erling Smørgrav 	} else
894b7579f77SDag-Erling Smørgrav 		*newq = NULL;
895c7f4d7adSDag-Erling Smørgrav 	return 1;
896c7f4d7adSDag-Erling Smørgrav }
897c7f4d7adSDag-Erling Smørgrav 
898c7f4d7adSDag-Erling Smørgrav int mesh_attach_sub(struct module_qstate* qstate, struct query_info* qinfo,
899c7f4d7adSDag-Erling Smørgrav         uint16_t qflags, int prime, int valrec, struct module_qstate** newq)
900c7f4d7adSDag-Erling Smørgrav {
901c7f4d7adSDag-Erling Smørgrav 	struct mesh_area* mesh = qstate->env->mesh;
902c7f4d7adSDag-Erling Smørgrav 	struct mesh_state* sub = NULL;
903c7f4d7adSDag-Erling Smørgrav 	int was_detached;
904c7f4d7adSDag-Erling Smørgrav 	if(!mesh_add_sub(qstate, qinfo, qflags, prime, valrec, newq, &sub))
905c7f4d7adSDag-Erling Smørgrav 		return 0;
9068ed2b524SDag-Erling Smørgrav 	was_detached = (sub->super_set.count == 0);
907b7579f77SDag-Erling Smørgrav 	if(!mesh_state_attachment(qstate->mesh_info, sub))
908b7579f77SDag-Erling Smørgrav 		return 0;
9098ed2b524SDag-Erling Smørgrav 	/* if it was a duplicate  attachment, the count was not zero before */
9108ed2b524SDag-Erling Smørgrav 	if(!sub->reply_list && !sub->cb_list && was_detached &&
9118ed2b524SDag-Erling Smørgrav 		sub->super_set.count == 1) {
912b7579f77SDag-Erling Smørgrav 		/* it used to be detached, before this one got added */
913b7579f77SDag-Erling Smørgrav 		log_assert(mesh->num_detached_states > 0);
914b7579f77SDag-Erling Smørgrav 		mesh->num_detached_states--;
915b7579f77SDag-Erling Smørgrav 	}
916b7579f77SDag-Erling Smørgrav 	/* *newq will be run when inited after the current module stops */
917b7579f77SDag-Erling Smørgrav 	return 1;
918b7579f77SDag-Erling Smørgrav }
919b7579f77SDag-Erling Smørgrav 
920b7579f77SDag-Erling Smørgrav int mesh_state_attachment(struct mesh_state* super, struct mesh_state* sub)
921b7579f77SDag-Erling Smørgrav {
922b7579f77SDag-Erling Smørgrav #ifdef UNBOUND_DEBUG
9233005e0a3SDag-Erling Smørgrav 	struct rbnode_type* n;
924b7579f77SDag-Erling Smørgrav #endif
925b7579f77SDag-Erling Smørgrav 	struct mesh_state_ref* subref; /* points to sub, inserted in super */
926b7579f77SDag-Erling Smørgrav 	struct mesh_state_ref* superref; /* points to super, inserted in sub */
927b7579f77SDag-Erling Smørgrav 	if( !(subref = regional_alloc(super->s.region,
928b7579f77SDag-Erling Smørgrav 		sizeof(struct mesh_state_ref))) ||
929b7579f77SDag-Erling Smørgrav 		!(superref = regional_alloc(sub->s.region,
930b7579f77SDag-Erling Smørgrav 		sizeof(struct mesh_state_ref))) ) {
931b7579f77SDag-Erling Smørgrav 		log_err("mesh_state_attachment: out of memory");
932b7579f77SDag-Erling Smørgrav 		return 0;
933b7579f77SDag-Erling Smørgrav 	}
934b7579f77SDag-Erling Smørgrav 	superref->node.key = superref;
935b7579f77SDag-Erling Smørgrav 	superref->s = super;
936b7579f77SDag-Erling Smørgrav 	subref->node.key = subref;
937b7579f77SDag-Erling Smørgrav 	subref->s = sub;
9388ed2b524SDag-Erling Smørgrav 	if(!rbtree_insert(&sub->super_set, &superref->node)) {
9398ed2b524SDag-Erling Smørgrav 		/* this should not happen, iterator and validator do not
9408ed2b524SDag-Erling Smørgrav 		 * attach subqueries that are identical. */
9418ed2b524SDag-Erling Smørgrav 		/* already attached, we are done, nothing todo.
9428ed2b524SDag-Erling Smørgrav 		 * since superref and subref already allocated in region,
9438ed2b524SDag-Erling Smørgrav 		 * we cannot free them */
9448ed2b524SDag-Erling Smørgrav 		return 1;
9458ed2b524SDag-Erling Smørgrav 	}
946b7579f77SDag-Erling Smørgrav #ifdef UNBOUND_DEBUG
947b7579f77SDag-Erling Smørgrav 	n =
94817d15b25SDag-Erling Smørgrav #else
94917d15b25SDag-Erling Smørgrav 	(void)
950b7579f77SDag-Erling Smørgrav #endif
951b7579f77SDag-Erling Smørgrav 	rbtree_insert(&super->sub_set, &subref->node);
9528ed2b524SDag-Erling Smørgrav 	log_assert(n != NULL); /* we checked above if statement, the reverse
9538ed2b524SDag-Erling Smørgrav 	  administration should not fail now, unless they are out of sync */
954b7579f77SDag-Erling Smørgrav 	return 1;
955b7579f77SDag-Erling Smørgrav }
956b7579f77SDag-Erling Smørgrav 
957b7579f77SDag-Erling Smørgrav /**
958b7579f77SDag-Erling Smørgrav  * callback results to mesh cb entry
959b7579f77SDag-Erling Smørgrav  * @param m: mesh state to send it for.
960b7579f77SDag-Erling Smørgrav  * @param rcode: if not 0, error code.
961b7579f77SDag-Erling Smørgrav  * @param rep: reply to send (or NULL if rcode is set).
962b7579f77SDag-Erling Smørgrav  * @param r: callback entry
963b7579f77SDag-Erling Smørgrav  */
964b7579f77SDag-Erling Smørgrav static void
965b7579f77SDag-Erling Smørgrav mesh_do_callback(struct mesh_state* m, int rcode, struct reply_info* rep,
966b7579f77SDag-Erling Smørgrav 	struct mesh_cb* r)
967b7579f77SDag-Erling Smørgrav {
968b7579f77SDag-Erling Smørgrav 	int secure;
969b7579f77SDag-Erling Smørgrav 	char* reason = NULL;
970b7579f77SDag-Erling Smørgrav 	/* bogus messages are not made into servfail, sec_status passed
971b7579f77SDag-Erling Smørgrav 	 * to the callback function */
972b7579f77SDag-Erling Smørgrav 	if(rep && rep->security == sec_status_secure)
973b7579f77SDag-Erling Smørgrav 		secure = 1;
974b7579f77SDag-Erling Smørgrav 	else	secure = 0;
975b7579f77SDag-Erling Smørgrav 	if(!rep && rcode == LDNS_RCODE_NOERROR)
976b7579f77SDag-Erling Smørgrav 		rcode = LDNS_RCODE_SERVFAIL;
977b7579f77SDag-Erling Smørgrav 	if(!rcode && rep->security == sec_status_bogus) {
978b7579f77SDag-Erling Smørgrav 		if(!(reason = errinf_to_str(&m->s)))
979b7579f77SDag-Erling Smørgrav 			rcode = LDNS_RCODE_SERVFAIL;
980b7579f77SDag-Erling Smørgrav 	}
981b7579f77SDag-Erling Smørgrav 	/* send the reply */
982b7579f77SDag-Erling Smørgrav 	if(rcode) {
983bc892140SDag-Erling Smørgrav 		if(rcode == LDNS_RCODE_SERVFAIL) {
984bc892140SDag-Erling Smørgrav 			if(!inplace_cb_reply_servfail_call(m->s.env, &m->s.qinfo, &m->s,
985bc892140SDag-Erling Smørgrav 				rep, rcode, &r->edns, m->s.region))
986bc892140SDag-Erling Smørgrav 					r->edns.opt_list = NULL;
987bc892140SDag-Erling Smørgrav 		} else {
988bc892140SDag-Erling Smørgrav 			if(!inplace_cb_reply_call(m->s.env, &m->s.qinfo, &m->s, rep, rcode,
989bc892140SDag-Erling Smørgrav 				&r->edns, m->s.region))
990bc892140SDag-Erling Smørgrav 					r->edns.opt_list = NULL;
991bc892140SDag-Erling Smørgrav 		}
992b7579f77SDag-Erling Smørgrav 		fptr_ok(fptr_whitelist_mesh_cb(r->cb));
993b7579f77SDag-Erling Smørgrav 		(*r->cb)(r->cb_arg, rcode, r->buf, sec_status_unchecked, NULL);
994b7579f77SDag-Erling Smørgrav 	} else {
995b7579f77SDag-Erling Smørgrav 		size_t udp_size = r->edns.udp_size;
99617d15b25SDag-Erling Smørgrav 		sldns_buffer_clear(r->buf);
997b7579f77SDag-Erling Smørgrav 		r->edns.edns_version = EDNS_ADVERTISED_VERSION;
998b7579f77SDag-Erling Smørgrav 		r->edns.udp_size = EDNS_ADVERTISED_SIZE;
999b7579f77SDag-Erling Smørgrav 		r->edns.ext_rcode = 0;
1000b7579f77SDag-Erling Smørgrav 		r->edns.bits &= EDNS_DO;
1001bc892140SDag-Erling Smørgrav 
1002bc892140SDag-Erling Smørgrav 		if(!inplace_cb_reply_call(m->s.env, &m->s.qinfo, &m->s, rep,
1003bc892140SDag-Erling Smørgrav 			LDNS_RCODE_NOERROR, &r->edns, m->s.region) ||
1004e2d15004SDag-Erling Smørgrav 			!reply_info_answer_encode(&m->s.qinfo, rep, r->qid,
1005b7579f77SDag-Erling Smørgrav 			r->qflags, r->buf, 0, 1,
1006b7579f77SDag-Erling Smørgrav 			m->s.env->scratch, udp_size, &r->edns,
1007b7579f77SDag-Erling Smørgrav 			(int)(r->edns.bits & EDNS_DO), secure))
1008b7579f77SDag-Erling Smørgrav 		{
1009b7579f77SDag-Erling Smørgrav 			fptr_ok(fptr_whitelist_mesh_cb(r->cb));
1010b7579f77SDag-Erling Smørgrav 			(*r->cb)(r->cb_arg, LDNS_RCODE_SERVFAIL, r->buf,
1011b7579f77SDag-Erling Smørgrav 				sec_status_unchecked, NULL);
1012b7579f77SDag-Erling Smørgrav 		} else {
1013b7579f77SDag-Erling Smørgrav 			fptr_ok(fptr_whitelist_mesh_cb(r->cb));
1014b7579f77SDag-Erling Smørgrav 			(*r->cb)(r->cb_arg, LDNS_RCODE_NOERROR, r->buf,
1015b7579f77SDag-Erling Smørgrav 				rep->security, reason);
1016b7579f77SDag-Erling Smørgrav 		}
1017b7579f77SDag-Erling Smørgrav 	}
1018b7579f77SDag-Erling Smørgrav 	free(reason);
1019b7579f77SDag-Erling Smørgrav 	m->s.env->mesh->num_reply_addrs--;
1020b7579f77SDag-Erling Smørgrav }
1021b7579f77SDag-Erling Smørgrav 
1022b7579f77SDag-Erling Smørgrav /**
1023b7579f77SDag-Erling Smørgrav  * Send reply to mesh reply entry
1024b7579f77SDag-Erling Smørgrav  * @param m: mesh state to send it for.
1025b7579f77SDag-Erling Smørgrav  * @param rcode: if not 0, error code.
1026b7579f77SDag-Erling Smørgrav  * @param rep: reply to send (or NULL if rcode is set).
1027b7579f77SDag-Erling Smørgrav  * @param r: reply entry
1028b7579f77SDag-Erling Smørgrav  * @param prev: previous reply, already has its answer encoded in buffer.
1029b7579f77SDag-Erling Smørgrav  */
1030b7579f77SDag-Erling Smørgrav static void
1031b7579f77SDag-Erling Smørgrav mesh_send_reply(struct mesh_state* m, int rcode, struct reply_info* rep,
1032b7579f77SDag-Erling Smørgrav 	struct mesh_reply* r, struct mesh_reply* prev)
1033b7579f77SDag-Erling Smørgrav {
1034b7579f77SDag-Erling Smørgrav 	struct timeval end_time;
1035b7579f77SDag-Erling Smørgrav 	struct timeval duration;
1036b7579f77SDag-Erling Smørgrav 	int secure;
1037bc892140SDag-Erling Smørgrav 	/* Copy the client's EDNS for later restore, to make sure the edns
1038bc892140SDag-Erling Smørgrav 	 * compare is with the correct edns options. */
1039bc892140SDag-Erling Smørgrav 	struct edns_data edns_bak = r->edns;
1040b7579f77SDag-Erling Smørgrav 	/* examine security status */
1041b7579f77SDag-Erling Smørgrav 	if(m->s.env->need_to_validate && (!(r->qflags&BIT_CD) ||
1042b7579f77SDag-Erling Smørgrav 		m->s.env->cfg->ignore_cd) && rep &&
1043b7579f77SDag-Erling Smørgrav 		rep->security <= sec_status_bogus) {
1044b7579f77SDag-Erling Smørgrav 		rcode = LDNS_RCODE_SERVFAIL;
1045b7579f77SDag-Erling Smørgrav 		if(m->s.env->cfg->stat_extended)
1046b7579f77SDag-Erling Smørgrav 			m->s.env->mesh->ans_bogus++;
1047b7579f77SDag-Erling Smørgrav 	}
1048b7579f77SDag-Erling Smørgrav 	if(rep && rep->security == sec_status_secure)
1049b7579f77SDag-Erling Smørgrav 		secure = 1;
1050b7579f77SDag-Erling Smørgrav 	else	secure = 0;
1051b7579f77SDag-Erling Smørgrav 	if(!rep && rcode == LDNS_RCODE_NOERROR)
1052b7579f77SDag-Erling Smørgrav 		rcode = LDNS_RCODE_SERVFAIL;
1053b7579f77SDag-Erling Smørgrav 	/* send the reply */
1054bc892140SDag-Erling Smørgrav 	/* We don't reuse the encoded answer if either the previous or current
1055bc892140SDag-Erling Smørgrav 	 * response has a local alias.  We could compare the alias records
1056bc892140SDag-Erling Smørgrav 	 * and still reuse the previous answer if they are the same, but that
1057bc892140SDag-Erling Smørgrav 	 * would be complicated and error prone for the relatively minor case.
1058bc892140SDag-Erling Smørgrav 	 * So we err on the side of safety. */
1059b7579f77SDag-Erling Smørgrav 	if(prev && prev->qflags == r->qflags &&
1060bc892140SDag-Erling Smørgrav 		!prev->local_alias && !r->local_alias &&
1061b7579f77SDag-Erling Smørgrav 		prev->edns.edns_present == r->edns.edns_present &&
1062b7579f77SDag-Erling Smørgrav 		prev->edns.bits == r->edns.bits &&
1063e2d15004SDag-Erling Smørgrav 		prev->edns.udp_size == r->edns.udp_size &&
1064e2d15004SDag-Erling Smørgrav 		edns_opt_list_compare(prev->edns.opt_list, r->edns.opt_list)
1065e2d15004SDag-Erling Smørgrav 		== 0) {
1066b7579f77SDag-Erling Smørgrav 		/* if the previous reply is identical to this one, fix ID */
1067b7579f77SDag-Erling Smørgrav 		if(prev->query_reply.c->buffer != r->query_reply.c->buffer)
106817d15b25SDag-Erling Smørgrav 			sldns_buffer_copy(r->query_reply.c->buffer,
1069b7579f77SDag-Erling Smørgrav 				prev->query_reply.c->buffer);
107017d15b25SDag-Erling Smørgrav 		sldns_buffer_write_at(r->query_reply.c->buffer, 0,
1071b7579f77SDag-Erling Smørgrav 			&r->qid, sizeof(uint16_t));
107217d15b25SDag-Erling Smørgrav 		sldns_buffer_write_at(r->query_reply.c->buffer, 12,
1073b7579f77SDag-Erling Smørgrav 			r->qname, m->s.qinfo.qname_len);
1074b7579f77SDag-Erling Smørgrav 		comm_point_send_reply(&r->query_reply);
1075b7579f77SDag-Erling Smørgrav 	} else if(rcode) {
1076b7579f77SDag-Erling Smørgrav 		m->s.qinfo.qname = r->qname;
1077bc892140SDag-Erling Smørgrav 		m->s.qinfo.local_alias = r->local_alias;
1078bc892140SDag-Erling Smørgrav 		if(rcode == LDNS_RCODE_SERVFAIL) {
1079bc892140SDag-Erling Smørgrav 			if(!inplace_cb_reply_servfail_call(m->s.env, &m->s.qinfo, &m->s,
1080bc892140SDag-Erling Smørgrav 				rep, rcode, &r->edns, m->s.region))
1081bc892140SDag-Erling Smørgrav 					r->edns.opt_list = NULL;
1082bc892140SDag-Erling Smørgrav 		} else {
1083bc892140SDag-Erling Smørgrav 			if(!inplace_cb_reply_call(m->s.env, &m->s.qinfo, &m->s, rep, rcode,
1084bc892140SDag-Erling Smørgrav 				&r->edns, m->s.region))
1085bc892140SDag-Erling Smørgrav 					r->edns.opt_list = NULL;
1086bc892140SDag-Erling Smørgrav 		}
1087b7579f77SDag-Erling Smørgrav 		error_encode(r->query_reply.c->buffer, rcode, &m->s.qinfo,
1088b7579f77SDag-Erling Smørgrav 			r->qid, r->qflags, &r->edns);
1089b7579f77SDag-Erling Smørgrav 		comm_point_send_reply(&r->query_reply);
1090b7579f77SDag-Erling Smørgrav 	} else {
1091b7579f77SDag-Erling Smørgrav 		size_t udp_size = r->edns.udp_size;
1092b7579f77SDag-Erling Smørgrav 		r->edns.edns_version = EDNS_ADVERTISED_VERSION;
1093b7579f77SDag-Erling Smørgrav 		r->edns.udp_size = EDNS_ADVERTISED_SIZE;
1094b7579f77SDag-Erling Smørgrav 		r->edns.ext_rcode = 0;
1095b7579f77SDag-Erling Smørgrav 		r->edns.bits &= EDNS_DO;
1096b7579f77SDag-Erling Smørgrav 		m->s.qinfo.qname = r->qname;
1097bc892140SDag-Erling Smørgrav 		m->s.qinfo.local_alias = r->local_alias;
1098bc892140SDag-Erling Smørgrav 		if(!inplace_cb_reply_call(m->s.env, &m->s.qinfo, &m->s, rep,
1099bc892140SDag-Erling Smørgrav 			LDNS_RCODE_NOERROR, &r->edns, m->s.region) ||
1100e2d15004SDag-Erling Smørgrav 			!reply_info_answer_encode(&m->s.qinfo, rep, r->qid,
1101b7579f77SDag-Erling Smørgrav 			r->qflags, r->query_reply.c->buffer, 0, 1,
1102b7579f77SDag-Erling Smørgrav 			m->s.env->scratch, udp_size, &r->edns,
1103b7579f77SDag-Erling Smørgrav 			(int)(r->edns.bits & EDNS_DO), secure))
1104b7579f77SDag-Erling Smørgrav 		{
1105bc892140SDag-Erling Smørgrav 			if(!inplace_cb_reply_servfail_call(m->s.env, &m->s.qinfo, &m->s,
1106bc892140SDag-Erling Smørgrav 			rep, LDNS_RCODE_SERVFAIL, &r->edns, m->s.region))
1107bc892140SDag-Erling Smørgrav 				r->edns.opt_list = NULL;
1108b7579f77SDag-Erling Smørgrav 			error_encode(r->query_reply.c->buffer,
1109b7579f77SDag-Erling Smørgrav 				LDNS_RCODE_SERVFAIL, &m->s.qinfo, r->qid,
1110b7579f77SDag-Erling Smørgrav 				r->qflags, &r->edns);
1111b7579f77SDag-Erling Smørgrav 		}
1112bc892140SDag-Erling Smørgrav 		r->edns = edns_bak;
1113b7579f77SDag-Erling Smørgrav 		comm_point_send_reply(&r->query_reply);
1114b7579f77SDag-Erling Smørgrav 	}
1115b7579f77SDag-Erling Smørgrav 	/* account */
1116b7579f77SDag-Erling Smørgrav 	m->s.env->mesh->num_reply_addrs--;
1117b7579f77SDag-Erling Smørgrav 	end_time = *m->s.env->now_tv;
1118b7579f77SDag-Erling Smørgrav 	timeval_subtract(&duration, &end_time, &r->start_time);
111917d15b25SDag-Erling Smørgrav 	verbose(VERB_ALGO, "query took " ARG_LL "d.%6.6d sec",
112017d15b25SDag-Erling Smørgrav 		(long long)duration.tv_sec, (int)duration.tv_usec);
1121b7579f77SDag-Erling Smørgrav 	m->s.env->mesh->replies_sent++;
1122b7579f77SDag-Erling Smørgrav 	timeval_add(&m->s.env->mesh->replies_sum_wait, &duration);
1123b7579f77SDag-Erling Smørgrav 	timehist_insert(m->s.env->mesh->histogram, &duration);
1124b7579f77SDag-Erling Smørgrav 	if(m->s.env->cfg->stat_extended) {
112517d15b25SDag-Erling Smørgrav 		uint16_t rc = FLAGS_GET_RCODE(sldns_buffer_read_u16_at(r->
1126b7579f77SDag-Erling Smørgrav 			query_reply.c->buffer, 2));
1127b7579f77SDag-Erling Smørgrav 		if(secure) m->s.env->mesh->ans_secure++;
1128b7579f77SDag-Erling Smørgrav 		m->s.env->mesh->ans_rcode[ rc ] ++;
112917d15b25SDag-Erling Smørgrav 		if(rc == 0 && LDNS_ANCOUNT(sldns_buffer_begin(r->
1130b7579f77SDag-Erling Smørgrav 			query_reply.c->buffer)) == 0)
1131b7579f77SDag-Erling Smørgrav 			m->s.env->mesh->ans_nodata++;
1132b7579f77SDag-Erling Smørgrav 	}
11333005e0a3SDag-Erling Smørgrav 	/* Log reply sent */
11343005e0a3SDag-Erling Smørgrav 	if(m->s.env->cfg->log_replies) {
11353005e0a3SDag-Erling Smørgrav 		log_reply_info(0, &m->s.qinfo, &r->query_reply.addr,
11363005e0a3SDag-Erling Smørgrav 			r->query_reply.addrlen, duration, 0,
11373005e0a3SDag-Erling Smørgrav 			r->query_reply.c->buffer);
11383005e0a3SDag-Erling Smørgrav 	}
1139b7579f77SDag-Erling Smørgrav }
1140b7579f77SDag-Erling Smørgrav 
1141b7579f77SDag-Erling Smørgrav void mesh_query_done(struct mesh_state* mstate)
1142b7579f77SDag-Erling Smørgrav {
1143b7579f77SDag-Erling Smørgrav 	struct mesh_reply* r;
1144b7579f77SDag-Erling Smørgrav 	struct mesh_reply* prev = NULL;
1145b7579f77SDag-Erling Smørgrav 	struct mesh_cb* c;
1146b7579f77SDag-Erling Smørgrav 	struct reply_info* rep = (mstate->s.return_msg?
1147b7579f77SDag-Erling Smørgrav 		mstate->s.return_msg->rep:NULL);
1148b7579f77SDag-Erling Smørgrav 	for(r = mstate->reply_list; r; r = r->next) {
114965b390aaSDag-Erling Smørgrav 		/* if a response-ip address block has been stored the
115065b390aaSDag-Erling Smørgrav 		 *  information should be logged for each client. */
115165b390aaSDag-Erling Smørgrav 		if(mstate->s.respip_action_info &&
115265b390aaSDag-Erling Smørgrav 			mstate->s.respip_action_info->addrinfo) {
115365b390aaSDag-Erling Smørgrav 			respip_inform_print(mstate->s.respip_action_info->addrinfo,
115465b390aaSDag-Erling Smørgrav 				r->qname, mstate->s.qinfo.qtype,
115565b390aaSDag-Erling Smørgrav 				mstate->s.qinfo.qclass, r->local_alias,
115665b390aaSDag-Erling Smørgrav 				&r->query_reply);
115765b390aaSDag-Erling Smørgrav 		}
115865b390aaSDag-Erling Smørgrav 
115965b390aaSDag-Erling Smørgrav 		/* if this query is determined to be dropped during the
116065b390aaSDag-Erling Smørgrav 		 * mesh processing, this is the point to take that action. */
116165b390aaSDag-Erling Smørgrav 		if(mstate->s.is_drop)
116265b390aaSDag-Erling Smørgrav 			comm_point_drop_reply(&r->query_reply);
116365b390aaSDag-Erling Smørgrav 		else {
116465b390aaSDag-Erling Smørgrav 			mesh_send_reply(mstate, mstate->s.return_rcode, rep,
116565b390aaSDag-Erling Smørgrav 				r, prev);
1166b7579f77SDag-Erling Smørgrav 			prev = r;
1167b7579f77SDag-Erling Smørgrav 		}
116865b390aaSDag-Erling Smørgrav 	}
1169b7579f77SDag-Erling Smørgrav 	mstate->replies_sent = 1;
1170b7579f77SDag-Erling Smørgrav 	for(c = mstate->cb_list; c; c = c->next) {
1171b7579f77SDag-Erling Smørgrav 		mesh_do_callback(mstate, mstate->s.return_rcode, rep, c);
1172b7579f77SDag-Erling Smørgrav 	}
1173b7579f77SDag-Erling Smørgrav }
1174b7579f77SDag-Erling Smørgrav 
1175b7579f77SDag-Erling Smørgrav void mesh_walk_supers(struct mesh_area* mesh, struct mesh_state* mstate)
1176b7579f77SDag-Erling Smørgrav {
1177b7579f77SDag-Erling Smørgrav 	struct mesh_state_ref* ref;
1178b7579f77SDag-Erling Smørgrav 	RBTREE_FOR(ref, struct mesh_state_ref*, &mstate->super_set)
1179b7579f77SDag-Erling Smørgrav 	{
1180b7579f77SDag-Erling Smørgrav 		/* make super runnable */
1181b7579f77SDag-Erling Smørgrav 		(void)rbtree_insert(&mesh->run, &ref->s->run_node);
1182b7579f77SDag-Erling Smørgrav 		/* callback the function to inform super of result */
1183b7579f77SDag-Erling Smørgrav 		fptr_ok(fptr_whitelist_mod_inform_super(
1184b7579f77SDag-Erling Smørgrav 			mesh->mods.mod[ref->s->s.curmod]->inform_super));
1185b7579f77SDag-Erling Smørgrav 		(*mesh->mods.mod[ref->s->s.curmod]->inform_super)(&mstate->s,
1186b7579f77SDag-Erling Smørgrav 			ref->s->s.curmod, &ref->s->s);
1187b7579f77SDag-Erling Smørgrav 	}
1188b7579f77SDag-Erling Smørgrav }
1189b7579f77SDag-Erling Smørgrav 
1190b7579f77SDag-Erling Smørgrav struct mesh_state* mesh_area_find(struct mesh_area* mesh,
119165b390aaSDag-Erling Smørgrav 	struct respip_client_info* cinfo, struct query_info* qinfo,
119265b390aaSDag-Erling Smørgrav 	uint16_t qflags, int prime, int valrec)
1193b7579f77SDag-Erling Smørgrav {
1194b7579f77SDag-Erling Smørgrav 	struct mesh_state key;
1195b7579f77SDag-Erling Smørgrav 	struct mesh_state* result;
1196b7579f77SDag-Erling Smørgrav 
1197b7579f77SDag-Erling Smørgrav 	key.node.key = &key;
1198b7579f77SDag-Erling Smørgrav 	key.s.is_priming = prime;
1199ff825849SDag-Erling Smørgrav 	key.s.is_valrec = valrec;
1200b7579f77SDag-Erling Smørgrav 	key.s.qinfo = *qinfo;
1201b7579f77SDag-Erling Smørgrav 	key.s.query_flags = qflags;
1202bc892140SDag-Erling Smørgrav 	/* We are searching for a similar mesh state when we DO want to
1203bc892140SDag-Erling Smørgrav 	 * aggregate the state. Thus unique is set to NULL. (default when we
1204bc892140SDag-Erling Smørgrav 	 * desire aggregation).*/
1205bc892140SDag-Erling Smørgrav 	key.unique = NULL;
120665b390aaSDag-Erling Smørgrav 	key.s.client_info = cinfo;
1207b7579f77SDag-Erling Smørgrav 
1208b7579f77SDag-Erling Smørgrav 	result = (struct mesh_state*)rbtree_search(&mesh->all, &key);
1209b7579f77SDag-Erling Smørgrav 	return result;
1210b7579f77SDag-Erling Smørgrav }
1211b7579f77SDag-Erling Smørgrav 
1212b7579f77SDag-Erling Smørgrav int mesh_state_add_cb(struct mesh_state* s, struct edns_data* edns,
12133005e0a3SDag-Erling Smørgrav         sldns_buffer* buf, mesh_cb_func_type cb, void* cb_arg,
1214b7579f77SDag-Erling Smørgrav 	uint16_t qid, uint16_t qflags)
1215b7579f77SDag-Erling Smørgrav {
1216b7579f77SDag-Erling Smørgrav 	struct mesh_cb* r = regional_alloc(s->s.region,
1217b7579f77SDag-Erling Smørgrav 		sizeof(struct mesh_cb));
1218b7579f77SDag-Erling Smørgrav 	if(!r)
1219b7579f77SDag-Erling Smørgrav 		return 0;
1220b7579f77SDag-Erling Smørgrav 	r->buf = buf;
1221b7579f77SDag-Erling Smørgrav 	log_assert(fptr_whitelist_mesh_cb(cb)); /* early failure ifmissing*/
1222b7579f77SDag-Erling Smørgrav 	r->cb = cb;
1223b7579f77SDag-Erling Smørgrav 	r->cb_arg = cb_arg;
1224b7579f77SDag-Erling Smørgrav 	r->edns = *edns;
1225e2d15004SDag-Erling Smørgrav 	if(edns->opt_list) {
1226e2d15004SDag-Erling Smørgrav 		r->edns.opt_list = edns_opt_copy_region(edns->opt_list,
1227e2d15004SDag-Erling Smørgrav 			s->s.region);
1228e2d15004SDag-Erling Smørgrav 		if(!r->edns.opt_list)
1229e2d15004SDag-Erling Smørgrav 			return 0;
1230e2d15004SDag-Erling Smørgrav 	}
1231b7579f77SDag-Erling Smørgrav 	r->qid = qid;
1232b7579f77SDag-Erling Smørgrav 	r->qflags = qflags;
1233b7579f77SDag-Erling Smørgrav 	r->next = s->cb_list;
1234b7579f77SDag-Erling Smørgrav 	s->cb_list = r;
1235b7579f77SDag-Erling Smørgrav 	return 1;
1236b7579f77SDag-Erling Smørgrav 
1237b7579f77SDag-Erling Smørgrav }
1238b7579f77SDag-Erling Smørgrav 
1239b7579f77SDag-Erling Smørgrav int mesh_state_add_reply(struct mesh_state* s, struct edns_data* edns,
1240bc892140SDag-Erling Smørgrav         struct comm_reply* rep, uint16_t qid, uint16_t qflags,
1241bc892140SDag-Erling Smørgrav         const struct query_info* qinfo)
1242b7579f77SDag-Erling Smørgrav {
1243b7579f77SDag-Erling Smørgrav 	struct mesh_reply* r = regional_alloc(s->s.region,
1244b7579f77SDag-Erling Smørgrav 		sizeof(struct mesh_reply));
1245b7579f77SDag-Erling Smørgrav 	if(!r)
1246b7579f77SDag-Erling Smørgrav 		return 0;
1247b7579f77SDag-Erling Smørgrav 	r->query_reply = *rep;
1248b7579f77SDag-Erling Smørgrav 	r->edns = *edns;
1249e2d15004SDag-Erling Smørgrav 	if(edns->opt_list) {
1250e2d15004SDag-Erling Smørgrav 		r->edns.opt_list = edns_opt_copy_region(edns->opt_list,
1251e2d15004SDag-Erling Smørgrav 			s->s.region);
1252e2d15004SDag-Erling Smørgrav 		if(!r->edns.opt_list)
1253e2d15004SDag-Erling Smørgrav 			return 0;
1254e2d15004SDag-Erling Smørgrav 	}
1255b7579f77SDag-Erling Smørgrav 	r->qid = qid;
1256b7579f77SDag-Erling Smørgrav 	r->qflags = qflags;
1257b7579f77SDag-Erling Smørgrav 	r->start_time = *s->s.env->now_tv;
1258b7579f77SDag-Erling Smørgrav 	r->next = s->reply_list;
1259bc892140SDag-Erling Smørgrav 	r->qname = regional_alloc_init(s->s.region, qinfo->qname,
1260b7579f77SDag-Erling Smørgrav 		s->s.qinfo.qname_len);
1261b7579f77SDag-Erling Smørgrav 	if(!r->qname)
1262b7579f77SDag-Erling Smørgrav 		return 0;
1263bc892140SDag-Erling Smørgrav 
1264bc892140SDag-Erling Smørgrav 	/* Data related to local alias stored in 'qinfo' (if any) is ephemeral
1265bc892140SDag-Erling Smørgrav 	 * and can be different for different original queries (even if the
1266bc892140SDag-Erling Smørgrav 	 * replaced query name is the same).  So we need to make a deep copy
1267bc892140SDag-Erling Smørgrav 	 * and store the copy for each reply info. */
1268bc892140SDag-Erling Smørgrav 	if(qinfo->local_alias) {
1269bc892140SDag-Erling Smørgrav 		struct packed_rrset_data* d;
1270bc892140SDag-Erling Smørgrav 		struct packed_rrset_data* dsrc;
1271bc892140SDag-Erling Smørgrav 		r->local_alias = regional_alloc_zero(s->s.region,
1272bc892140SDag-Erling Smørgrav 			sizeof(*qinfo->local_alias));
1273bc892140SDag-Erling Smørgrav 		if(!r->local_alias)
1274bc892140SDag-Erling Smørgrav 			return 0;
1275bc892140SDag-Erling Smørgrav 		r->local_alias->rrset = regional_alloc_init(s->s.region,
1276bc892140SDag-Erling Smørgrav 			qinfo->local_alias->rrset,
1277bc892140SDag-Erling Smørgrav 			sizeof(*qinfo->local_alias->rrset));
1278bc892140SDag-Erling Smørgrav 		if(!r->local_alias->rrset)
1279bc892140SDag-Erling Smørgrav 			return 0;
1280bc892140SDag-Erling Smørgrav 		dsrc = qinfo->local_alias->rrset->entry.data;
1281bc892140SDag-Erling Smørgrav 
1282bc892140SDag-Erling Smørgrav 		/* In the current implementation, a local alias must be
1283bc892140SDag-Erling Smørgrav 		 * a single CNAME RR (see worker_handle_request()). */
1284bc892140SDag-Erling Smørgrav 		log_assert(!qinfo->local_alias->next && dsrc->count == 1 &&
1285bc892140SDag-Erling Smørgrav 			qinfo->local_alias->rrset->rk.type ==
1286bc892140SDag-Erling Smørgrav 			htons(LDNS_RR_TYPE_CNAME));
1287bc892140SDag-Erling Smørgrav 		/* Technically, we should make a local copy for the owner
1288bc892140SDag-Erling Smørgrav 		 * name of the RRset, but in the case of the first (and
1289bc892140SDag-Erling Smørgrav 		 * currently only) local alias RRset, the owner name should
1290bc892140SDag-Erling Smørgrav 		 * point to the qname of the corresponding query, which should
1291bc892140SDag-Erling Smørgrav 		 * be valid throughout the lifetime of this mesh_reply.  So
1292bc892140SDag-Erling Smørgrav 		 * we can skip copying. */
1293bc892140SDag-Erling Smørgrav 		log_assert(qinfo->local_alias->rrset->rk.dname ==
1294bc892140SDag-Erling Smørgrav 			sldns_buffer_at(rep->c->buffer, LDNS_HEADER_SIZE));
1295bc892140SDag-Erling Smørgrav 
1296bc892140SDag-Erling Smørgrav 		d = regional_alloc_init(s->s.region, dsrc,
1297bc892140SDag-Erling Smørgrav 			sizeof(struct packed_rrset_data)
1298bc892140SDag-Erling Smørgrav 			+ sizeof(size_t) + sizeof(uint8_t*) + sizeof(time_t));
1299bc892140SDag-Erling Smørgrav 		if(!d)
1300bc892140SDag-Erling Smørgrav 			return 0;
1301bc892140SDag-Erling Smørgrav 		r->local_alias->rrset->entry.data = d;
1302bc892140SDag-Erling Smørgrav 		d->rr_len = (size_t*)((uint8_t*)d +
1303bc892140SDag-Erling Smørgrav 			sizeof(struct packed_rrset_data));
1304bc892140SDag-Erling Smørgrav 		d->rr_data = (uint8_t**)&(d->rr_len[1]);
1305bc892140SDag-Erling Smørgrav 		d->rr_ttl = (time_t*)&(d->rr_data[1]);
1306bc892140SDag-Erling Smørgrav 		d->rr_len[0] = dsrc->rr_len[0];
1307bc892140SDag-Erling Smørgrav 		d->rr_ttl[0] = dsrc->rr_ttl[0];
1308bc892140SDag-Erling Smørgrav 		d->rr_data[0] = regional_alloc_init(s->s.region,
1309bc892140SDag-Erling Smørgrav 			dsrc->rr_data[0], d->rr_len[0]);
1310bc892140SDag-Erling Smørgrav 		if(!d->rr_data[0])
1311bc892140SDag-Erling Smørgrav 			return 0;
1312bc892140SDag-Erling Smørgrav 	} else
1313bc892140SDag-Erling Smørgrav 		r->local_alias = NULL;
1314bc892140SDag-Erling Smørgrav 
1315b7579f77SDag-Erling Smørgrav 	s->reply_list = r;
1316b7579f77SDag-Erling Smørgrav 	return 1;
1317b7579f77SDag-Erling Smørgrav }
1318b7579f77SDag-Erling Smørgrav 
1319*8a384985SDag-Erling Smørgrav /* Extract the query info and flags from 'mstate' into '*qinfop' and '*qflags'.
1320*8a384985SDag-Erling Smørgrav  * Since this is only used for internal refetch of otherwise-expired answer,
1321*8a384985SDag-Erling Smørgrav  * we simply ignore the rare failure mode when memory allocation fails. */
1322*8a384985SDag-Erling Smørgrav static void
1323*8a384985SDag-Erling Smørgrav mesh_copy_qinfo(struct mesh_state* mstate, struct query_info** qinfop,
1324*8a384985SDag-Erling Smørgrav 	uint16_t* qflags)
1325*8a384985SDag-Erling Smørgrav {
1326*8a384985SDag-Erling Smørgrav 	struct regional* region = mstate->s.env->scratch;
1327*8a384985SDag-Erling Smørgrav 	struct query_info* qinfo;
1328*8a384985SDag-Erling Smørgrav 
1329*8a384985SDag-Erling Smørgrav 	qinfo = regional_alloc_init(region, &mstate->s.qinfo, sizeof(*qinfo));
1330*8a384985SDag-Erling Smørgrav 	if(!qinfo)
1331*8a384985SDag-Erling Smørgrav 		return;
1332*8a384985SDag-Erling Smørgrav 	qinfo->qname = regional_alloc_init(region, qinfo->qname,
1333*8a384985SDag-Erling Smørgrav 		qinfo->qname_len);
1334*8a384985SDag-Erling Smørgrav 	if(!qinfo->qname)
1335*8a384985SDag-Erling Smørgrav 		return;
1336*8a384985SDag-Erling Smørgrav 	*qinfop = qinfo;
1337*8a384985SDag-Erling Smørgrav 	*qflags = mstate->s.query_flags;
1338*8a384985SDag-Erling Smørgrav }
1339*8a384985SDag-Erling Smørgrav 
1340b7579f77SDag-Erling Smørgrav /**
1341b7579f77SDag-Erling Smørgrav  * Continue processing the mesh state at another module.
1342*8a384985SDag-Erling Smørgrav  * Handles module to modules transfer of control.
1343b7579f77SDag-Erling Smørgrav  * Handles module finished.
1344b7579f77SDag-Erling Smørgrav  * @param mesh: the mesh area.
1345b7579f77SDag-Erling Smørgrav  * @param mstate: currently active mesh state.
1346b7579f77SDag-Erling Smørgrav  * 	Deleted if finished, calls _done and _supers to
1347b7579f77SDag-Erling Smørgrav  * 	send replies to clients and inform other mesh states.
1348b7579f77SDag-Erling Smørgrav  * 	This in turn may create additional runnable mesh states.
1349b7579f77SDag-Erling Smørgrav  * @param s: state at which the current module exited.
1350b7579f77SDag-Erling Smørgrav  * @param ev: the event sent to the module.
1351b7579f77SDag-Erling Smørgrav  * 	returned is the event to send to the next module.
1352b7579f77SDag-Erling Smørgrav  * @return true if continue processing at the new module.
1353b7579f77SDag-Erling Smørgrav  * 	false if not continued processing is needed.
1354b7579f77SDag-Erling Smørgrav  */
1355b7579f77SDag-Erling Smørgrav static int
1356b7579f77SDag-Erling Smørgrav mesh_continue(struct mesh_area* mesh, struct mesh_state* mstate,
1357b7579f77SDag-Erling Smørgrav 	enum module_ext_state s, enum module_ev* ev)
1358b7579f77SDag-Erling Smørgrav {
1359b7579f77SDag-Erling Smørgrav 	mstate->num_activated++;
1360b7579f77SDag-Erling Smørgrav 	if(mstate->num_activated > MESH_MAX_ACTIVATION) {
1361b7579f77SDag-Erling Smørgrav 		/* module is looping. Stop it. */
1362*8a384985SDag-Erling Smørgrav 		log_err("internal error: looping module (%s) stopped",
1363*8a384985SDag-Erling Smørgrav 			mesh->mods.mod[mstate->s.curmod]->name);
1364b7579f77SDag-Erling Smørgrav 		log_query_info(VERB_QUERY, "pass error for qstate",
1365b7579f77SDag-Erling Smørgrav 			&mstate->s.qinfo);
1366b7579f77SDag-Erling Smørgrav 		s = module_error;
1367b7579f77SDag-Erling Smørgrav 	}
1368b7579f77SDag-Erling Smørgrav 	if(s == module_wait_module || s == module_restart_next) {
1369b7579f77SDag-Erling Smørgrav 		/* start next module */
1370b7579f77SDag-Erling Smørgrav 		mstate->s.curmod++;
1371b7579f77SDag-Erling Smørgrav 		if(mesh->mods.num == mstate->s.curmod) {
1372b7579f77SDag-Erling Smørgrav 			log_err("Cannot pass to next module; at last module");
1373b7579f77SDag-Erling Smørgrav 			log_query_info(VERB_QUERY, "pass error for qstate",
1374b7579f77SDag-Erling Smørgrav 				&mstate->s.qinfo);
1375b7579f77SDag-Erling Smørgrav 			mstate->s.curmod--;
1376b7579f77SDag-Erling Smørgrav 			return mesh_continue(mesh, mstate, module_error, ev);
1377b7579f77SDag-Erling Smørgrav 		}
1378b7579f77SDag-Erling Smørgrav 		if(s == module_restart_next) {
137965b390aaSDag-Erling Smørgrav 			int curmod = mstate->s.curmod;
138065b390aaSDag-Erling Smørgrav 			for(; mstate->s.curmod < mesh->mods.num;
138165b390aaSDag-Erling Smørgrav 				mstate->s.curmod++) {
1382b7579f77SDag-Erling Smørgrav 				fptr_ok(fptr_whitelist_mod_clear(
1383b7579f77SDag-Erling Smørgrav 					mesh->mods.mod[mstate->s.curmod]->clear));
1384b7579f77SDag-Erling Smørgrav 				(*mesh->mods.mod[mstate->s.curmod]->clear)
1385b7579f77SDag-Erling Smørgrav 					(&mstate->s, mstate->s.curmod);
1386b7579f77SDag-Erling Smørgrav 				mstate->s.minfo[mstate->s.curmod] = NULL;
1387b7579f77SDag-Erling Smørgrav 			}
138865b390aaSDag-Erling Smørgrav 			mstate->s.curmod = curmod;
138965b390aaSDag-Erling Smørgrav 		}
1390b7579f77SDag-Erling Smørgrav 		*ev = module_event_pass;
1391b7579f77SDag-Erling Smørgrav 		return 1;
1392b7579f77SDag-Erling Smørgrav 	}
1393b5663de9SDag-Erling Smørgrav 	if(s == module_wait_subquery && mstate->sub_set.count == 0) {
1394b5663de9SDag-Erling Smørgrav 		log_err("module cannot wait for subquery, subquery list empty");
1395b5663de9SDag-Erling Smørgrav 		log_query_info(VERB_QUERY, "pass error for qstate",
1396b5663de9SDag-Erling Smørgrav 			&mstate->s.qinfo);
1397b5663de9SDag-Erling Smørgrav 		s = module_error;
1398b5663de9SDag-Erling Smørgrav 	}
1399b7579f77SDag-Erling Smørgrav 	if(s == module_error && mstate->s.return_rcode == LDNS_RCODE_NOERROR) {
1400b7579f77SDag-Erling Smørgrav 		/* error is bad, handle pass back up below */
1401b7579f77SDag-Erling Smørgrav 		mstate->s.return_rcode = LDNS_RCODE_SERVFAIL;
1402b7579f77SDag-Erling Smørgrav 	}
1403*8a384985SDag-Erling Smørgrav 	if(s == module_error) {
1404b7579f77SDag-Erling Smørgrav 		mesh_query_done(mstate);
1405b7579f77SDag-Erling Smørgrav 		mesh_walk_supers(mesh, mstate);
1406b7579f77SDag-Erling Smørgrav 		mesh_state_delete(&mstate->s);
1407b7579f77SDag-Erling Smørgrav 		return 0;
1408b7579f77SDag-Erling Smørgrav 	}
1409*8a384985SDag-Erling Smørgrav 	if(s == module_finished) {
1410*8a384985SDag-Erling Smørgrav 		if(mstate->s.curmod == 0) {
1411*8a384985SDag-Erling Smørgrav 			struct query_info* qinfo = NULL;
1412*8a384985SDag-Erling Smørgrav 			uint16_t qflags;
1413*8a384985SDag-Erling Smørgrav 
1414*8a384985SDag-Erling Smørgrav 			mesh_query_done(mstate);
1415*8a384985SDag-Erling Smørgrav 			mesh_walk_supers(mesh, mstate);
1416*8a384985SDag-Erling Smørgrav 
1417*8a384985SDag-Erling Smørgrav 			/* If the answer to the query needs to be refetched
1418*8a384985SDag-Erling Smørgrav 			 * from an external DNS server, we'll need to schedule
1419*8a384985SDag-Erling Smørgrav 			 * a prefetch after removing the current state, so
1420*8a384985SDag-Erling Smørgrav 			 * we need to make a copy of the query info here. */
1421*8a384985SDag-Erling Smørgrav 			if(mstate->s.need_refetch)
1422*8a384985SDag-Erling Smørgrav 				mesh_copy_qinfo(mstate, &qinfo, &qflags);
1423*8a384985SDag-Erling Smørgrav 
1424*8a384985SDag-Erling Smørgrav 			mesh_state_delete(&mstate->s);
1425*8a384985SDag-Erling Smørgrav 			if(qinfo) {
1426*8a384985SDag-Erling Smørgrav 				mesh_schedule_prefetch(mesh, qinfo, qflags,
1427*8a384985SDag-Erling Smørgrav 					0, 1);
1428*8a384985SDag-Erling Smørgrav 			}
1429*8a384985SDag-Erling Smørgrav 			return 0;
1430*8a384985SDag-Erling Smørgrav 		}
1431b7579f77SDag-Erling Smørgrav 		/* pass along the locus of control */
1432b7579f77SDag-Erling Smørgrav 		mstate->s.curmod --;
1433b7579f77SDag-Erling Smørgrav 		*ev = module_event_moddone;
1434b7579f77SDag-Erling Smørgrav 		return 1;
1435b7579f77SDag-Erling Smørgrav 	}
1436b7579f77SDag-Erling Smørgrav 	return 0;
1437b7579f77SDag-Erling Smørgrav }
1438b7579f77SDag-Erling Smørgrav 
1439b7579f77SDag-Erling Smørgrav void mesh_run(struct mesh_area* mesh, struct mesh_state* mstate,
1440b7579f77SDag-Erling Smørgrav 	enum module_ev ev, struct outbound_entry* e)
1441b7579f77SDag-Erling Smørgrav {
1442b7579f77SDag-Erling Smørgrav 	enum module_ext_state s;
1443b7579f77SDag-Erling Smørgrav 	verbose(VERB_ALGO, "mesh_run: start");
1444b7579f77SDag-Erling Smørgrav 	while(mstate) {
1445b7579f77SDag-Erling Smørgrav 		/* run the module */
1446b7579f77SDag-Erling Smørgrav 		fptr_ok(fptr_whitelist_mod_operate(
1447b7579f77SDag-Erling Smørgrav 			mesh->mods.mod[mstate->s.curmod]->operate));
1448b7579f77SDag-Erling Smørgrav 		(*mesh->mods.mod[mstate->s.curmod]->operate)
1449b7579f77SDag-Erling Smørgrav 			(&mstate->s, ev, mstate->s.curmod, e);
1450b7579f77SDag-Erling Smørgrav 
1451b7579f77SDag-Erling Smørgrav 		/* examine results */
1452b7579f77SDag-Erling Smørgrav 		mstate->s.reply = NULL;
1453b7579f77SDag-Erling Smørgrav 		regional_free_all(mstate->s.env->scratch);
1454b7579f77SDag-Erling Smørgrav 		s = mstate->s.ext_state[mstate->s.curmod];
1455b7579f77SDag-Erling Smørgrav 		verbose(VERB_ALGO, "mesh_run: %s module exit state is %s",
1456b7579f77SDag-Erling Smørgrav 			mesh->mods.mod[mstate->s.curmod]->name, strextstate(s));
1457b7579f77SDag-Erling Smørgrav 		e = NULL;
1458b7579f77SDag-Erling Smørgrav 		if(mesh_continue(mesh, mstate, s, &ev))
1459b7579f77SDag-Erling Smørgrav 			continue;
1460b7579f77SDag-Erling Smørgrav 
1461b7579f77SDag-Erling Smørgrav 		/* run more modules */
1462b7579f77SDag-Erling Smørgrav 		ev = module_event_pass;
1463b7579f77SDag-Erling Smørgrav 		if(mesh->run.count > 0) {
1464b7579f77SDag-Erling Smørgrav 			/* pop random element off the runnable tree */
1465b7579f77SDag-Erling Smørgrav 			mstate = (struct mesh_state*)mesh->run.root->key;
1466b7579f77SDag-Erling Smørgrav 			(void)rbtree_delete(&mesh->run, mstate);
1467b7579f77SDag-Erling Smørgrav 		} else mstate = NULL;
1468b7579f77SDag-Erling Smørgrav 	}
1469b7579f77SDag-Erling Smørgrav 	if(verbosity >= VERB_ALGO) {
1470b7579f77SDag-Erling Smørgrav 		mesh_stats(mesh, "mesh_run: end");
1471b7579f77SDag-Erling Smørgrav 		mesh_log_list(mesh);
1472b7579f77SDag-Erling Smørgrav 	}
1473b7579f77SDag-Erling Smørgrav }
1474b7579f77SDag-Erling Smørgrav 
1475b7579f77SDag-Erling Smørgrav void
1476b7579f77SDag-Erling Smørgrav mesh_log_list(struct mesh_area* mesh)
1477b7579f77SDag-Erling Smørgrav {
1478b7579f77SDag-Erling Smørgrav 	char buf[30];
1479b7579f77SDag-Erling Smørgrav 	struct mesh_state* m;
1480b7579f77SDag-Erling Smørgrav 	int num = 0;
1481b7579f77SDag-Erling Smørgrav 	RBTREE_FOR(m, struct mesh_state*, &mesh->all) {
1482ff825849SDag-Erling Smørgrav 		snprintf(buf, sizeof(buf), "%d%s%s%s%s%s%s mod%d %s%s",
1483b7579f77SDag-Erling Smørgrav 			num++, (m->s.is_priming)?"p":"",  /* prime */
1484ff825849SDag-Erling Smørgrav 			(m->s.is_valrec)?"v":"",  /* prime */
1485b7579f77SDag-Erling Smørgrav 			(m->s.query_flags&BIT_RD)?"RD":"",
1486b7579f77SDag-Erling Smørgrav 			(m->s.query_flags&BIT_CD)?"CD":"",
1487b7579f77SDag-Erling Smørgrav 			(m->super_set.count==0)?"d":"", /* detached */
1488b7579f77SDag-Erling Smørgrav 			(m->sub_set.count!=0)?"c":"",  /* children */
1489b7579f77SDag-Erling Smørgrav 			m->s.curmod, (m->reply_list)?"rep":"", /*hasreply*/
1490b7579f77SDag-Erling Smørgrav 			(m->cb_list)?"cb":"" /* callbacks */
1491b7579f77SDag-Erling Smørgrav 			);
1492b7579f77SDag-Erling Smørgrav 		log_query_info(VERB_ALGO, buf, &m->s.qinfo);
1493b7579f77SDag-Erling Smørgrav 	}
1494b7579f77SDag-Erling Smørgrav }
1495b7579f77SDag-Erling Smørgrav 
1496b7579f77SDag-Erling Smørgrav void
1497b7579f77SDag-Erling Smørgrav mesh_stats(struct mesh_area* mesh, const char* str)
1498b7579f77SDag-Erling Smørgrav {
1499b7579f77SDag-Erling Smørgrav 	verbose(VERB_DETAIL, "%s %u recursion states (%u with reply, "
1500b7579f77SDag-Erling Smørgrav 		"%u detached), %u waiting replies, %u recursion replies "
1501b7579f77SDag-Erling Smørgrav 		"sent, %d replies dropped, %d states jostled out",
1502b7579f77SDag-Erling Smørgrav 		str, (unsigned)mesh->all.count,
1503b7579f77SDag-Erling Smørgrav 		(unsigned)mesh->num_reply_states,
1504b7579f77SDag-Erling Smørgrav 		(unsigned)mesh->num_detached_states,
1505b7579f77SDag-Erling Smørgrav 		(unsigned)mesh->num_reply_addrs,
1506b7579f77SDag-Erling Smørgrav 		(unsigned)mesh->replies_sent,
1507b7579f77SDag-Erling Smørgrav 		(unsigned)mesh->stats_dropped,
1508b7579f77SDag-Erling Smørgrav 		(unsigned)mesh->stats_jostled);
1509b7579f77SDag-Erling Smørgrav 	if(mesh->replies_sent > 0) {
1510b7579f77SDag-Erling Smørgrav 		struct timeval avg;
1511b7579f77SDag-Erling Smørgrav 		timeval_divide(&avg, &mesh->replies_sum_wait,
1512b7579f77SDag-Erling Smørgrav 			mesh->replies_sent);
1513b7579f77SDag-Erling Smørgrav 		log_info("average recursion processing time "
151417d15b25SDag-Erling Smørgrav 			ARG_LL "d.%6.6d sec",
151517d15b25SDag-Erling Smørgrav 			(long long)avg.tv_sec, (int)avg.tv_usec);
1516b7579f77SDag-Erling Smørgrav 		log_info("histogram of recursion processing times");
1517b7579f77SDag-Erling Smørgrav 		timehist_log(mesh->histogram, "recursions");
1518b7579f77SDag-Erling Smørgrav 	}
1519b7579f77SDag-Erling Smørgrav }
1520b7579f77SDag-Erling Smørgrav 
1521b7579f77SDag-Erling Smørgrav void
1522b7579f77SDag-Erling Smørgrav mesh_stats_clear(struct mesh_area* mesh)
1523b7579f77SDag-Erling Smørgrav {
1524b7579f77SDag-Erling Smørgrav 	if(!mesh)
1525b7579f77SDag-Erling Smørgrav 		return;
1526b7579f77SDag-Erling Smørgrav 	mesh->replies_sent = 0;
1527b7579f77SDag-Erling Smørgrav 	mesh->replies_sum_wait.tv_sec = 0;
1528b7579f77SDag-Erling Smørgrav 	mesh->replies_sum_wait.tv_usec = 0;
1529b7579f77SDag-Erling Smørgrav 	mesh->stats_jostled = 0;
1530b7579f77SDag-Erling Smørgrav 	mesh->stats_dropped = 0;
1531b7579f77SDag-Erling Smørgrav 	timehist_clear(mesh->histogram);
1532b7579f77SDag-Erling Smørgrav 	mesh->ans_secure = 0;
1533b7579f77SDag-Erling Smørgrav 	mesh->ans_bogus = 0;
1534b7579f77SDag-Erling Smørgrav 	memset(&mesh->ans_rcode[0], 0, sizeof(size_t)*16);
1535b7579f77SDag-Erling Smørgrav 	mesh->ans_nodata = 0;
1536b7579f77SDag-Erling Smørgrav }
1537b7579f77SDag-Erling Smørgrav 
1538b7579f77SDag-Erling Smørgrav size_t
1539b7579f77SDag-Erling Smørgrav mesh_get_mem(struct mesh_area* mesh)
1540b7579f77SDag-Erling Smørgrav {
1541b7579f77SDag-Erling Smørgrav 	struct mesh_state* m;
1542b7579f77SDag-Erling Smørgrav 	size_t s = sizeof(*mesh) + sizeof(struct timehist) +
1543b7579f77SDag-Erling Smørgrav 		sizeof(struct th_buck)*mesh->histogram->num +
154417d15b25SDag-Erling Smørgrav 		sizeof(sldns_buffer) + sldns_buffer_capacity(mesh->qbuf_bak);
1545b7579f77SDag-Erling Smørgrav 	RBTREE_FOR(m, struct mesh_state*, &mesh->all) {
1546b7579f77SDag-Erling Smørgrav 		/* all, including m itself allocated in qstate region */
1547b7579f77SDag-Erling Smørgrav 		s += regional_get_mem(m->s.region);
1548b7579f77SDag-Erling Smørgrav 	}
1549b7579f77SDag-Erling Smørgrav 	return s;
1550b7579f77SDag-Erling Smørgrav }
1551b7579f77SDag-Erling Smørgrav 
1552b7579f77SDag-Erling Smørgrav int
1553b7579f77SDag-Erling Smørgrav mesh_detect_cycle(struct module_qstate* qstate, struct query_info* qinfo,
1554ff825849SDag-Erling Smørgrav 	uint16_t flags, int prime, int valrec)
1555b7579f77SDag-Erling Smørgrav {
1556b7579f77SDag-Erling Smørgrav 	struct mesh_area* mesh = qstate->env->mesh;
1557bc892140SDag-Erling Smørgrav 	struct mesh_state* dep_m = NULL;
1558bc892140SDag-Erling Smørgrav 	if(!mesh_state_is_unique(qstate->mesh_info))
155965b390aaSDag-Erling Smørgrav 		dep_m = mesh_area_find(mesh, NULL, qinfo, flags, prime, valrec);
1560b7579f77SDag-Erling Smørgrav 	return mesh_detect_cycle_found(qstate, dep_m);
1561b7579f77SDag-Erling Smørgrav }
1562b7579f77SDag-Erling Smørgrav 
1563b7579f77SDag-Erling Smørgrav void mesh_list_insert(struct mesh_state* m, struct mesh_state** fp,
1564b7579f77SDag-Erling Smørgrav         struct mesh_state** lp)
1565b7579f77SDag-Erling Smørgrav {
1566b7579f77SDag-Erling Smørgrav 	/* insert as last element */
1567b7579f77SDag-Erling Smørgrav 	m->prev = *lp;
1568b7579f77SDag-Erling Smørgrav 	m->next = NULL;
1569b7579f77SDag-Erling Smørgrav 	if(*lp)
1570b7579f77SDag-Erling Smørgrav 		(*lp)->next = m;
1571b7579f77SDag-Erling Smørgrav 	else	*fp = m;
1572b7579f77SDag-Erling Smørgrav 	*lp = m;
1573b7579f77SDag-Erling Smørgrav }
1574b7579f77SDag-Erling Smørgrav 
1575b7579f77SDag-Erling Smørgrav void mesh_list_remove(struct mesh_state* m, struct mesh_state** fp,
1576b7579f77SDag-Erling Smørgrav         struct mesh_state** lp)
1577b7579f77SDag-Erling Smørgrav {
1578b7579f77SDag-Erling Smørgrav 	if(m->next)
1579b7579f77SDag-Erling Smørgrav 		m->next->prev = m->prev;
1580b7579f77SDag-Erling Smørgrav 	else	*lp = m->prev;
1581b7579f77SDag-Erling Smørgrav 	if(m->prev)
1582b7579f77SDag-Erling Smørgrav 		m->prev->next = m->next;
1583b7579f77SDag-Erling Smørgrav 	else	*fp = m->next;
1584b7579f77SDag-Erling Smørgrav }
1585