xref: /freebsd/contrib/unbound/services/outside_network.c (revision 4c75e3aa0f1368f18240b8bfd0e1e88f64994a1c)
1b7579f77SDag-Erling Smørgrav /*
2b7579f77SDag-Erling Smørgrav  * services/outside_network.c - implement sending of queries and wait answer.
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 has functions to send queries to authoritative servers and
40b7579f77SDag-Erling Smørgrav  * wait for the pending answer events.
41b7579f77SDag-Erling Smørgrav  */
42b7579f77SDag-Erling Smørgrav #include "config.h"
43b7579f77SDag-Erling Smørgrav #include <ctype.h>
44b7579f77SDag-Erling Smørgrav #ifdef HAVE_SYS_TYPES_H
45b7579f77SDag-Erling Smørgrav #  include <sys/types.h>
46b7579f77SDag-Erling Smørgrav #endif
47b7579f77SDag-Erling Smørgrav #include <sys/time.h>
48b7579f77SDag-Erling Smørgrav #include "services/outside_network.h"
49b7579f77SDag-Erling Smørgrav #include "services/listen_dnsport.h"
50b7579f77SDag-Erling Smørgrav #include "services/cache/infra.h"
51*4c75e3aaSDag-Erling Smørgrav #include "iterator/iterator.h"
52b7579f77SDag-Erling Smørgrav #include "util/data/msgparse.h"
53b7579f77SDag-Erling Smørgrav #include "util/data/msgreply.h"
54b7579f77SDag-Erling Smørgrav #include "util/data/msgencode.h"
55b7579f77SDag-Erling Smørgrav #include "util/data/dname.h"
56b7579f77SDag-Erling Smørgrav #include "util/netevent.h"
57b7579f77SDag-Erling Smørgrav #include "util/log.h"
58b7579f77SDag-Erling Smørgrav #include "util/net_help.h"
59b7579f77SDag-Erling Smørgrav #include "util/random.h"
60b7579f77SDag-Erling Smørgrav #include "util/fptr_wlist.h"
6109a3aaf3SDag-Erling Smørgrav #include "sldns/sbuffer.h"
62ff825849SDag-Erling Smørgrav #include "dnstap/dnstap.h"
638ed2b524SDag-Erling Smørgrav #ifdef HAVE_OPENSSL_SSL_H
64b7579f77SDag-Erling Smørgrav #include <openssl/ssl.h>
658ed2b524SDag-Erling Smørgrav #endif
66b7579f77SDag-Erling Smørgrav 
67b7579f77SDag-Erling Smørgrav #ifdef HAVE_NETDB_H
68b7579f77SDag-Erling Smørgrav #include <netdb.h>
69b7579f77SDag-Erling Smørgrav #endif
70b7579f77SDag-Erling Smørgrav #include <fcntl.h>
71b7579f77SDag-Erling Smørgrav 
72b7579f77SDag-Erling Smørgrav /** number of times to retry making a random ID that is unique. */
73b7579f77SDag-Erling Smørgrav #define MAX_ID_RETRY 1000
74b7579f77SDag-Erling Smørgrav /** number of times to retry finding interface, port that can be opened. */
75b7579f77SDag-Erling Smørgrav #define MAX_PORT_RETRY 10000
76b7579f77SDag-Erling Smørgrav /** number of retries on outgoing UDP queries */
77b7579f77SDag-Erling Smørgrav #define OUTBOUND_UDP_RETRY 1
78b7579f77SDag-Erling Smørgrav 
79b7579f77SDag-Erling Smørgrav /** initiate TCP transaction for serviced query */
80ff825849SDag-Erling Smørgrav static void serviced_tcp_initiate(struct serviced_query* sq, sldns_buffer* buff);
81b7579f77SDag-Erling Smørgrav /** with a fd available, randomize and send UDP */
82ff825849SDag-Erling Smørgrav static int randomize_and_send_udp(struct pending* pend, sldns_buffer* packet,
83ff825849SDag-Erling Smørgrav 	int timeout);
84ff825849SDag-Erling Smørgrav 
85ff825849SDag-Erling Smørgrav /** remove waiting tcp from the outnet waiting list */
86ff825849SDag-Erling Smørgrav static void waiting_list_remove(struct outside_network* outnet,
87ff825849SDag-Erling Smørgrav 	struct waiting_tcp* w);
88b7579f77SDag-Erling Smørgrav 
89b7579f77SDag-Erling Smørgrav int
90b7579f77SDag-Erling Smørgrav pending_cmp(const void* key1, const void* key2)
91b7579f77SDag-Erling Smørgrav {
92b7579f77SDag-Erling Smørgrav 	struct pending *p1 = (struct pending*)key1;
93b7579f77SDag-Erling Smørgrav 	struct pending *p2 = (struct pending*)key2;
94b7579f77SDag-Erling Smørgrav 	if(p1->id < p2->id)
95b7579f77SDag-Erling Smørgrav 		return -1;
96b7579f77SDag-Erling Smørgrav 	if(p1->id > p2->id)
97b7579f77SDag-Erling Smørgrav 		return 1;
98b7579f77SDag-Erling Smørgrav 	log_assert(p1->id == p2->id);
99b7579f77SDag-Erling Smørgrav 	return sockaddr_cmp(&p1->addr, p1->addrlen, &p2->addr, p2->addrlen);
100b7579f77SDag-Erling Smørgrav }
101b7579f77SDag-Erling Smørgrav 
102b7579f77SDag-Erling Smørgrav int
103b7579f77SDag-Erling Smørgrav serviced_cmp(const void* key1, const void* key2)
104b7579f77SDag-Erling Smørgrav {
105b7579f77SDag-Erling Smørgrav 	struct serviced_query* q1 = (struct serviced_query*)key1;
106b7579f77SDag-Erling Smørgrav 	struct serviced_query* q2 = (struct serviced_query*)key2;
107b7579f77SDag-Erling Smørgrav 	int r;
108b7579f77SDag-Erling Smørgrav 	if(q1->qbuflen < q2->qbuflen)
109b7579f77SDag-Erling Smørgrav 		return -1;
110b7579f77SDag-Erling Smørgrav 	if(q1->qbuflen > q2->qbuflen)
111b7579f77SDag-Erling Smørgrav 		return 1;
112b7579f77SDag-Erling Smørgrav 	log_assert(q1->qbuflen == q2->qbuflen);
113b7579f77SDag-Erling Smørgrav 	log_assert(q1->qbuflen >= 15 /* 10 header, root, type, class */);
114b7579f77SDag-Erling Smørgrav 	/* alternate casing of qname is still the same query */
115b7579f77SDag-Erling Smørgrav 	if((r = memcmp(q1->qbuf, q2->qbuf, 10)) != 0)
116b7579f77SDag-Erling Smørgrav 		return r;
117b7579f77SDag-Erling Smørgrav 	if((r = memcmp(q1->qbuf+q1->qbuflen-4, q2->qbuf+q2->qbuflen-4, 4)) != 0)
118b7579f77SDag-Erling Smørgrav 		return r;
119b7579f77SDag-Erling Smørgrav 	if(q1->dnssec != q2->dnssec) {
120b7579f77SDag-Erling Smørgrav 		if(q1->dnssec < q2->dnssec)
121b7579f77SDag-Erling Smørgrav 			return -1;
122b7579f77SDag-Erling Smørgrav 		return 1;
123b7579f77SDag-Erling Smørgrav 	}
124b7579f77SDag-Erling Smørgrav 	if((r = query_dname_compare(q1->qbuf+10, q2->qbuf+10)) != 0)
125b7579f77SDag-Erling Smørgrav 		return r;
126e2d15004SDag-Erling Smørgrav 	if((r = edns_opt_list_compare(q1->opt_list, q2->opt_list)) != 0)
127e2d15004SDag-Erling Smørgrav 		return r;
128b7579f77SDag-Erling Smørgrav 	return sockaddr_cmp(&q1->addr, q1->addrlen, &q2->addr, q2->addrlen);
129b7579f77SDag-Erling Smørgrav }
130b7579f77SDag-Erling Smørgrav 
131b7579f77SDag-Erling Smørgrav /** delete waiting_tcp entry. Does not unlink from waiting list.
132b7579f77SDag-Erling Smørgrav  * @param w: to delete.
133b7579f77SDag-Erling Smørgrav  */
134b7579f77SDag-Erling Smørgrav static void
135b7579f77SDag-Erling Smørgrav waiting_tcp_delete(struct waiting_tcp* w)
136b7579f77SDag-Erling Smørgrav {
137b7579f77SDag-Erling Smørgrav 	if(!w) return;
138b7579f77SDag-Erling Smørgrav 	if(w->timer)
139b7579f77SDag-Erling Smørgrav 		comm_timer_delete(w->timer);
140b7579f77SDag-Erling Smørgrav 	free(w);
141b7579f77SDag-Erling Smørgrav }
142b7579f77SDag-Erling Smørgrav 
143b7579f77SDag-Erling Smørgrav /**
144b7579f77SDag-Erling Smørgrav  * Pick random outgoing-interface of that family, and bind it.
145b7579f77SDag-Erling Smørgrav  * port set to 0 so OS picks a port number for us.
146b7579f77SDag-Erling Smørgrav  * if it is the ANY address, do not bind.
147b7579f77SDag-Erling Smørgrav  * @param w: tcp structure with destination address.
148b7579f77SDag-Erling Smørgrav  * @param s: socket fd.
149b7579f77SDag-Erling Smørgrav  * @return false on error, socket closed.
150b7579f77SDag-Erling Smørgrav  */
151b7579f77SDag-Erling Smørgrav static int
152b7579f77SDag-Erling Smørgrav pick_outgoing_tcp(struct waiting_tcp* w, int s)
153b7579f77SDag-Erling Smørgrav {
154b7579f77SDag-Erling Smørgrav 	struct port_if* pi = NULL;
155b7579f77SDag-Erling Smørgrav 	int num;
156b7579f77SDag-Erling Smørgrav #ifdef INET6
157b7579f77SDag-Erling Smørgrav 	if(addr_is_ip6(&w->addr, w->addrlen))
158b7579f77SDag-Erling Smørgrav 		num = w->outnet->num_ip6;
159b7579f77SDag-Erling Smørgrav 	else
160b7579f77SDag-Erling Smørgrav #endif
161b7579f77SDag-Erling Smørgrav 		num = w->outnet->num_ip4;
162b7579f77SDag-Erling Smørgrav 	if(num == 0) {
163b7579f77SDag-Erling Smørgrav 		log_err("no TCP outgoing interfaces of family");
164b7579f77SDag-Erling Smørgrav 		log_addr(VERB_OPS, "for addr", &w->addr, w->addrlen);
165b7579f77SDag-Erling Smørgrav #ifndef USE_WINSOCK
166b7579f77SDag-Erling Smørgrav 		close(s);
167b7579f77SDag-Erling Smørgrav #else
168b7579f77SDag-Erling Smørgrav 		closesocket(s);
169b7579f77SDag-Erling Smørgrav #endif
170b7579f77SDag-Erling Smørgrav 		return 0;
171b7579f77SDag-Erling Smørgrav 	}
172b7579f77SDag-Erling Smørgrav #ifdef INET6
173b7579f77SDag-Erling Smørgrav 	if(addr_is_ip6(&w->addr, w->addrlen))
174b7579f77SDag-Erling Smørgrav 		pi = &w->outnet->ip6_ifs[ub_random_max(w->outnet->rnd, num)];
175b7579f77SDag-Erling Smørgrav 	else
176b7579f77SDag-Erling Smørgrav #endif
177b7579f77SDag-Erling Smørgrav 		pi = &w->outnet->ip4_ifs[ub_random_max(w->outnet->rnd, num)];
178b7579f77SDag-Erling Smørgrav 	log_assert(pi);
179b7579f77SDag-Erling Smørgrav 	if(addr_is_any(&pi->addr, pi->addrlen)) {
180b7579f77SDag-Erling Smørgrav 		/* binding to the ANY interface is for listening sockets */
181b7579f77SDag-Erling Smørgrav 		return 1;
182b7579f77SDag-Erling Smørgrav 	}
183b7579f77SDag-Erling Smørgrav 	/* set port to 0 */
184b7579f77SDag-Erling Smørgrav 	if(addr_is_ip6(&pi->addr, pi->addrlen))
185b7579f77SDag-Erling Smørgrav 		((struct sockaddr_in6*)&pi->addr)->sin6_port = 0;
186b7579f77SDag-Erling Smørgrav 	else	((struct sockaddr_in*)&pi->addr)->sin_port = 0;
187b7579f77SDag-Erling Smørgrav 	if(bind(s, (struct sockaddr*)&pi->addr, pi->addrlen) != 0) {
188b7579f77SDag-Erling Smørgrav #ifndef USE_WINSOCK
189b7579f77SDag-Erling Smørgrav 		log_err("outgoing tcp: bind: %s", strerror(errno));
190b7579f77SDag-Erling Smørgrav 		close(s);
191b7579f77SDag-Erling Smørgrav #else
192b7579f77SDag-Erling Smørgrav 		log_err("outgoing tcp: bind: %s",
193b7579f77SDag-Erling Smørgrav 			wsa_strerror(WSAGetLastError()));
194b7579f77SDag-Erling Smørgrav 		closesocket(s);
195b7579f77SDag-Erling Smørgrav #endif
196b7579f77SDag-Erling Smørgrav 		return 0;
197b7579f77SDag-Erling Smørgrav 	}
198b7579f77SDag-Erling Smørgrav 	log_addr(VERB_ALGO, "tcp bound to src", &pi->addr, pi->addrlen);
199b7579f77SDag-Erling Smørgrav 	return 1;
200b7579f77SDag-Erling Smørgrav }
201b7579f77SDag-Erling Smørgrav 
20257bddd21SDag-Erling Smørgrav /** get TCP file descriptor for address, returns -1 on failure,
20357bddd21SDag-Erling Smørgrav  * tcp_mss is 0 or maxseg size to set for TCP packets. */
20457bddd21SDag-Erling Smørgrav int
20557bddd21SDag-Erling Smørgrav outnet_get_tcp_fd(struct sockaddr_storage* addr, socklen_t addrlen, int tcp_mss)
206b7579f77SDag-Erling Smørgrav {
207b7579f77SDag-Erling Smørgrav 	int s;
208c7f4d7adSDag-Erling Smørgrav #ifdef SO_REUSEADDR
209c7f4d7adSDag-Erling Smørgrav 	int on = 1;
210c7f4d7adSDag-Erling Smørgrav #endif
211b7579f77SDag-Erling Smørgrav #ifdef INET6
21257bddd21SDag-Erling Smørgrav 	if(addr_is_ip6(addr, addrlen))
213b7579f77SDag-Erling Smørgrav 		s = socket(PF_INET6, SOCK_STREAM, IPPROTO_TCP);
214b7579f77SDag-Erling Smørgrav 	else
215b7579f77SDag-Erling Smørgrav #endif
216b7579f77SDag-Erling Smørgrav 		s = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
217b7579f77SDag-Erling Smørgrav 	if(s == -1) {
218b7579f77SDag-Erling Smørgrav #ifndef USE_WINSOCK
219ff825849SDag-Erling Smørgrav 		log_err_addr("outgoing tcp: socket", strerror(errno),
22057bddd21SDag-Erling Smørgrav 			addr, addrlen);
221b7579f77SDag-Erling Smørgrav #else
222ff825849SDag-Erling Smørgrav 		log_err_addr("outgoing tcp: socket",
22357bddd21SDag-Erling Smørgrav 			wsa_strerror(WSAGetLastError()), addr, addrlen);
224b7579f77SDag-Erling Smørgrav #endif
22557bddd21SDag-Erling Smørgrav 		return -1;
226b7579f77SDag-Erling Smørgrav 	}
227f61ef7f6SDag-Erling Smørgrav 
228c7f4d7adSDag-Erling Smørgrav #ifdef SO_REUSEADDR
229c7f4d7adSDag-Erling Smørgrav 	if(setsockopt(s, SOL_SOCKET, SO_REUSEADDR, (void*)&on,
230c7f4d7adSDag-Erling Smørgrav 		(socklen_t)sizeof(on)) < 0) {
231c7f4d7adSDag-Erling Smørgrav 		verbose(VERB_ALGO, "outgoing tcp:"
232c7f4d7adSDag-Erling Smørgrav 			" setsockopt(.. SO_REUSEADDR ..) failed");
233c7f4d7adSDag-Erling Smørgrav 	}
234c7f4d7adSDag-Erling Smørgrav #endif
23557bddd21SDag-Erling Smørgrav 
23657bddd21SDag-Erling Smørgrav 	if(tcp_mss > 0) {
237f61ef7f6SDag-Erling Smørgrav #if defined(IPPROTO_TCP) && defined(TCP_MAXSEG)
238f61ef7f6SDag-Erling Smørgrav 		if(setsockopt(s, IPPROTO_TCP, TCP_MAXSEG,
23957bddd21SDag-Erling Smørgrav 			(void*)&tcp_mss, (socklen_t)sizeof(tcp_mss)) < 0) {
240f61ef7f6SDag-Erling Smørgrav 			verbose(VERB_ALGO, "outgoing tcp:"
241c7f4d7adSDag-Erling Smørgrav 				" setsockopt(.. TCP_MAXSEG ..) failed");
242f61ef7f6SDag-Erling Smørgrav 		}
243f61ef7f6SDag-Erling Smørgrav #else
244f61ef7f6SDag-Erling Smørgrav 		verbose(VERB_ALGO, "outgoing tcp:"
245f61ef7f6SDag-Erling Smørgrav 			" setsockopt(TCP_MAXSEG) unsupported");
246f61ef7f6SDag-Erling Smørgrav #endif /* defined(IPPROTO_TCP) && defined(TCP_MAXSEG) */
247f61ef7f6SDag-Erling Smørgrav 	}
248f61ef7f6SDag-Erling Smørgrav 
24957bddd21SDag-Erling Smørgrav 	return s;
25057bddd21SDag-Erling Smørgrav }
25157bddd21SDag-Erling Smørgrav 
25257bddd21SDag-Erling Smørgrav /** connect tcp connection to addr, 0 on failure */
25357bddd21SDag-Erling Smørgrav int
25457bddd21SDag-Erling Smørgrav outnet_tcp_connect(int s, struct sockaddr_storage* addr, socklen_t addrlen)
25557bddd21SDag-Erling Smørgrav {
25657bddd21SDag-Erling Smørgrav 	if(connect(s, (struct sockaddr*)addr, addrlen) == -1) {
25757bddd21SDag-Erling Smørgrav #ifndef USE_WINSOCK
25857bddd21SDag-Erling Smørgrav #ifdef EINPROGRESS
25957bddd21SDag-Erling Smørgrav 		if(errno != EINPROGRESS) {
26057bddd21SDag-Erling Smørgrav #endif
26157bddd21SDag-Erling Smørgrav 			if(tcp_connect_errno_needs_log(
26257bddd21SDag-Erling Smørgrav 				(struct sockaddr*)addr, addrlen))
26357bddd21SDag-Erling Smørgrav 				log_err_addr("outgoing tcp: connect",
26457bddd21SDag-Erling Smørgrav 					strerror(errno), addr, addrlen);
26557bddd21SDag-Erling Smørgrav 			close(s);
26657bddd21SDag-Erling Smørgrav 			return 0;
26757bddd21SDag-Erling Smørgrav #ifdef EINPROGRESS
26857bddd21SDag-Erling Smørgrav 		}
26957bddd21SDag-Erling Smørgrav #endif
27057bddd21SDag-Erling Smørgrav #else /* USE_WINSOCK */
27157bddd21SDag-Erling Smørgrav 		if(WSAGetLastError() != WSAEINPROGRESS &&
27257bddd21SDag-Erling Smørgrav 			WSAGetLastError() != WSAEWOULDBLOCK) {
27357bddd21SDag-Erling Smørgrav 			closesocket(s);
27457bddd21SDag-Erling Smørgrav 			return 0;
27557bddd21SDag-Erling Smørgrav 		}
27657bddd21SDag-Erling Smørgrav #endif
27757bddd21SDag-Erling Smørgrav 	}
27857bddd21SDag-Erling Smørgrav 	return 1;
27957bddd21SDag-Erling Smørgrav }
28057bddd21SDag-Erling Smørgrav 
28157bddd21SDag-Erling Smørgrav /** use next free buffer to service a tcp query */
28257bddd21SDag-Erling Smørgrav static int
28357bddd21SDag-Erling Smørgrav outnet_tcp_take_into_use(struct waiting_tcp* w, uint8_t* pkt, size_t pkt_len)
28457bddd21SDag-Erling Smørgrav {
28557bddd21SDag-Erling Smørgrav 	struct pending_tcp* pend = w->outnet->tcp_free;
28657bddd21SDag-Erling Smørgrav 	int s;
28757bddd21SDag-Erling Smørgrav 	log_assert(pend);
28857bddd21SDag-Erling Smørgrav 	log_assert(pkt);
28957bddd21SDag-Erling Smørgrav 	log_assert(w->addrlen > 0);
29057bddd21SDag-Erling Smørgrav 	/* open socket */
29157bddd21SDag-Erling Smørgrav 	s = outnet_get_tcp_fd(&w->addr, w->addrlen, w->outnet->tcp_mss);
29257bddd21SDag-Erling Smørgrav 
293b7579f77SDag-Erling Smørgrav 	if(!pick_outgoing_tcp(w, s))
294b7579f77SDag-Erling Smørgrav 		return 0;
295b7579f77SDag-Erling Smørgrav 
296b7579f77SDag-Erling Smørgrav 	fd_set_nonblock(s);
297b5663de9SDag-Erling Smørgrav #ifdef USE_OSX_MSG_FASTOPEN
298b5663de9SDag-Erling Smørgrav 	/* API for fast open is different here. We use a connectx() function and
299b5663de9SDag-Erling Smørgrav 	   then writes can happen as normal even using SSL.*/
300b5663de9SDag-Erling Smørgrav 	/* connectx requires that the len be set in the sockaddr struct*/
301b5663de9SDag-Erling Smørgrav 	struct sockaddr_in *addr_in = (struct sockaddr_in *)&w->addr;
302b5663de9SDag-Erling Smørgrav 	addr_in->sin_len = w->addrlen;
303b5663de9SDag-Erling Smørgrav 	sa_endpoints_t endpoints;
304b5663de9SDag-Erling Smørgrav 	endpoints.sae_srcif = 0;
305b5663de9SDag-Erling Smørgrav 	endpoints.sae_srcaddr = NULL;
306b5663de9SDag-Erling Smørgrav 	endpoints.sae_srcaddrlen = 0;
307b5663de9SDag-Erling Smørgrav 	endpoints.sae_dstaddr = (struct sockaddr *)&w->addr;
308b5663de9SDag-Erling Smørgrav 	endpoints.sae_dstaddrlen = w->addrlen;
309b5663de9SDag-Erling Smørgrav 	if (connectx(s, &endpoints, SAE_ASSOCID_ANY,
310b5663de9SDag-Erling Smørgrav 	             CONNECT_DATA_IDEMPOTENT | CONNECT_RESUME_ON_READ_WRITE,
311b5663de9SDag-Erling Smørgrav 	             NULL, 0, NULL, NULL) == -1) {
312971980c3SDag-Erling Smørgrav 		/* if fails, failover to connect for OSX 10.10 */
313971980c3SDag-Erling Smørgrav #ifdef EINPROGRESS
314971980c3SDag-Erling Smørgrav 		if(errno != EINPROGRESS) {
315971980c3SDag-Erling Smørgrav #else
316971980c3SDag-Erling Smørgrav 		if(1) {
317971980c3SDag-Erling Smørgrav #endif
318971980c3SDag-Erling Smørgrav 			if(connect(s, (struct sockaddr*)&w->addr, w->addrlen) == -1) {
319b5663de9SDag-Erling Smørgrav #else /* USE_OSX_MSG_FASTOPEN*/
320b5663de9SDag-Erling Smørgrav #ifdef USE_MSG_FASTOPEN
321b5663de9SDag-Erling Smørgrav 	pend->c->tcp_do_fastopen = 1;
322b5663de9SDag-Erling Smørgrav 	/* Only do TFO for TCP in which case no connect() is required here.
323b5663de9SDag-Erling Smørgrav 	   Don't combine client TFO with SSL, since OpenSSL can't
324b5663de9SDag-Erling Smørgrav 	   currently support doing a handshake on fd that already isn't connected*/
325b5663de9SDag-Erling Smørgrav 	if (w->outnet->sslctx && w->ssl_upstream) {
326b7579f77SDag-Erling Smørgrav 		if(connect(s, (struct sockaddr*)&w->addr, w->addrlen) == -1) {
327b5663de9SDag-Erling Smørgrav #else /* USE_MSG_FASTOPEN*/
328b5663de9SDag-Erling Smørgrav 	if(connect(s, (struct sockaddr*)&w->addr, w->addrlen) == -1) {
329b5663de9SDag-Erling Smørgrav #endif /* USE_MSG_FASTOPEN*/
330b5663de9SDag-Erling Smørgrav #endif /* USE_OSX_MSG_FASTOPEN*/
331b7579f77SDag-Erling Smørgrav #ifndef USE_WINSOCK
332b7579f77SDag-Erling Smørgrav #ifdef EINPROGRESS
333b7579f77SDag-Erling Smørgrav 		if(errno != EINPROGRESS) {
334b7579f77SDag-Erling Smørgrav #else
335b7579f77SDag-Erling Smørgrav 		if(1) {
336b7579f77SDag-Erling Smørgrav #endif
337b7579f77SDag-Erling Smørgrav 			if(tcp_connect_errno_needs_log(
338b7579f77SDag-Erling Smørgrav 				(struct sockaddr*)&w->addr, w->addrlen))
339ff825849SDag-Erling Smørgrav 				log_err_addr("outgoing tcp: connect",
340ff825849SDag-Erling Smørgrav 					strerror(errno), &w->addr, w->addrlen);
341b7579f77SDag-Erling Smørgrav 			close(s);
342b7579f77SDag-Erling Smørgrav #else /* USE_WINSOCK */
343b7579f77SDag-Erling Smørgrav 		if(WSAGetLastError() != WSAEINPROGRESS &&
344b7579f77SDag-Erling Smørgrav 			WSAGetLastError() != WSAEWOULDBLOCK) {
345b7579f77SDag-Erling Smørgrav 			closesocket(s);
346b7579f77SDag-Erling Smørgrav #endif
347b7579f77SDag-Erling Smørgrav 			return 0;
348b7579f77SDag-Erling Smørgrav 		}
349b7579f77SDag-Erling Smørgrav 	}
350b5663de9SDag-Erling Smørgrav #ifdef USE_MSG_FASTOPEN
351b5663de9SDag-Erling Smørgrav 	}
352b5663de9SDag-Erling Smørgrav #endif /* USE_MSG_FASTOPEN */
353971980c3SDag-Erling Smørgrav #ifdef USE_OSX_MSG_FASTOPEN
354971980c3SDag-Erling Smørgrav 		}
355971980c3SDag-Erling Smørgrav 	}
356971980c3SDag-Erling Smørgrav #endif /* USE_OSX_MSG_FASTOPEN */
357b7579f77SDag-Erling Smørgrav 	if(w->outnet->sslctx && w->ssl_upstream) {
358b7579f77SDag-Erling Smørgrav 		pend->c->ssl = outgoing_ssl_fd(w->outnet->sslctx, s);
359b7579f77SDag-Erling Smørgrav 		if(!pend->c->ssl) {
360b7579f77SDag-Erling Smørgrav 			pend->c->fd = s;
361b7579f77SDag-Erling Smørgrav 			comm_point_close(pend->c);
362b7579f77SDag-Erling Smørgrav 			return 0;
363b7579f77SDag-Erling Smørgrav 		}
364b7579f77SDag-Erling Smørgrav #ifdef USE_WINSOCK
365b7579f77SDag-Erling Smørgrav 		comm_point_tcp_win_bio_cb(pend->c, pend->c->ssl);
366b7579f77SDag-Erling Smørgrav #endif
367b7579f77SDag-Erling Smørgrav 		pend->c->ssl_shake_state = comm_ssl_shake_write;
3680fb34990SDag-Erling Smørgrav #ifdef HAVE_SSL_SET1_HOST
3690fb34990SDag-Erling Smørgrav 		if(w->tls_auth_name) {
3700fb34990SDag-Erling Smørgrav 			SSL_set_verify(pend->c->ssl, SSL_VERIFY_PEER, NULL);
3710fb34990SDag-Erling Smørgrav 			/* setting the hostname makes openssl verify the
3720fb34990SDag-Erling Smørgrav                          * host name in the x509 certificate in the
3730fb34990SDag-Erling Smørgrav                          * SSL connection*/
3740fb34990SDag-Erling Smørgrav                         if(!SSL_set1_host(pend->c->ssl, w->tls_auth_name)) {
3750fb34990SDag-Erling Smørgrav                                 log_err("SSL_set1_host failed");
3760fb34990SDag-Erling Smørgrav 				pend->c->fd = s;
3770fb34990SDag-Erling Smørgrav 				comm_point_close(pend->c);
3780fb34990SDag-Erling Smørgrav 				return 0;
3790fb34990SDag-Erling Smørgrav 			}
3800fb34990SDag-Erling Smørgrav 		}
3810fb34990SDag-Erling Smørgrav #endif /* HAVE_SSL_SET1_HOST */
382b7579f77SDag-Erling Smørgrav 	}
383b7579f77SDag-Erling Smørgrav 	w->pkt = NULL;
384b7579f77SDag-Erling Smørgrav 	w->next_waiting = (void*)pend;
385b7579f77SDag-Erling Smørgrav 	pend->id = LDNS_ID_WIRE(pkt);
386ff825849SDag-Erling Smørgrav 	w->outnet->num_tcp_outgoing++;
387b7579f77SDag-Erling Smørgrav 	w->outnet->tcp_free = pend->next_free;
388b7579f77SDag-Erling Smørgrav 	pend->next_free = NULL;
389b7579f77SDag-Erling Smørgrav 	pend->query = w;
390b7579f77SDag-Erling Smørgrav 	pend->c->repinfo.addrlen = w->addrlen;
391b7579f77SDag-Erling Smørgrav 	memcpy(&pend->c->repinfo.addr, &w->addr, w->addrlen);
39217d15b25SDag-Erling Smørgrav 	sldns_buffer_clear(pend->c->buffer);
39317d15b25SDag-Erling Smørgrav 	sldns_buffer_write(pend->c->buffer, pkt, pkt_len);
39417d15b25SDag-Erling Smørgrav 	sldns_buffer_flip(pend->c->buffer);
395b7579f77SDag-Erling Smørgrav 	pend->c->tcp_is_reading = 0;
396b7579f77SDag-Erling Smørgrav 	pend->c->tcp_byte_count = 0;
397b7579f77SDag-Erling Smørgrav 	comm_point_start_listening(pend->c, s, -1);
398b7579f77SDag-Erling Smørgrav 	return 1;
399b7579f77SDag-Erling Smørgrav }
400b7579f77SDag-Erling Smørgrav 
401b7579f77SDag-Erling Smørgrav /** see if buffers can be used to service TCP queries */
402b7579f77SDag-Erling Smørgrav static void
403b7579f77SDag-Erling Smørgrav use_free_buffer(struct outside_network* outnet)
404b7579f77SDag-Erling Smørgrav {
405b7579f77SDag-Erling Smørgrav 	struct waiting_tcp* w;
406b7579f77SDag-Erling Smørgrav 	while(outnet->tcp_free && outnet->tcp_wait_first
407b7579f77SDag-Erling Smørgrav 		&& !outnet->want_to_quit) {
408b7579f77SDag-Erling Smørgrav 		w = outnet->tcp_wait_first;
409b7579f77SDag-Erling Smørgrav 		outnet->tcp_wait_first = w->next_waiting;
410b7579f77SDag-Erling Smørgrav 		if(outnet->tcp_wait_last == w)
411b7579f77SDag-Erling Smørgrav 			outnet->tcp_wait_last = NULL;
412b7579f77SDag-Erling Smørgrav 		if(!outnet_tcp_take_into_use(w, w->pkt, w->pkt_len)) {
4133005e0a3SDag-Erling Smørgrav 			comm_point_callback_type* cb = w->cb;
414b7579f77SDag-Erling Smørgrav 			void* cb_arg = w->cb_arg;
415b7579f77SDag-Erling Smørgrav 			waiting_tcp_delete(w);
416b7579f77SDag-Erling Smørgrav 			fptr_ok(fptr_whitelist_pending_tcp(cb));
417b7579f77SDag-Erling Smørgrav 			(void)(*cb)(NULL, cb_arg, NETEVENT_CLOSED, NULL);
418b7579f77SDag-Erling Smørgrav 		}
419b7579f77SDag-Erling Smørgrav 	}
420b7579f77SDag-Erling Smørgrav }
421b7579f77SDag-Erling Smørgrav 
4228a384985SDag-Erling Smørgrav /** decommission a tcp buffer, closes commpoint and frees waiting_tcp entry */
423b7579f77SDag-Erling Smørgrav static void
4248a384985SDag-Erling Smørgrav decommission_pending_tcp(struct outside_network* outnet,
425b7579f77SDag-Erling Smørgrav 	struct pending_tcp* pend)
426b7579f77SDag-Erling Smørgrav {
427b7579f77SDag-Erling Smørgrav 	if(pend->c->ssl) {
4288ed2b524SDag-Erling Smørgrav #ifdef HAVE_SSL
429b7579f77SDag-Erling Smørgrav 		SSL_shutdown(pend->c->ssl);
430b7579f77SDag-Erling Smørgrav 		SSL_free(pend->c->ssl);
431b7579f77SDag-Erling Smørgrav 		pend->c->ssl = NULL;
4328ed2b524SDag-Erling Smørgrav #endif
433b7579f77SDag-Erling Smørgrav 	}
434b7579f77SDag-Erling Smørgrav 	comm_point_close(pend->c);
435b7579f77SDag-Erling Smørgrav 	pend->next_free = outnet->tcp_free;
436b7579f77SDag-Erling Smørgrav 	outnet->tcp_free = pend;
437b7579f77SDag-Erling Smørgrav 	waiting_tcp_delete(pend->query);
438b7579f77SDag-Erling Smørgrav 	pend->query = NULL;
439b7579f77SDag-Erling Smørgrav 	use_free_buffer(outnet);
440b7579f77SDag-Erling Smørgrav }
441b7579f77SDag-Erling Smørgrav 
442b7579f77SDag-Erling Smørgrav int
443b7579f77SDag-Erling Smørgrav outnet_tcp_cb(struct comm_point* c, void* arg, int error,
444b7579f77SDag-Erling Smørgrav 	struct comm_reply *reply_info)
445b7579f77SDag-Erling Smørgrav {
446b7579f77SDag-Erling Smørgrav 	struct pending_tcp* pend = (struct pending_tcp*)arg;
447b7579f77SDag-Erling Smørgrav 	struct outside_network* outnet = pend->query->outnet;
448b7579f77SDag-Erling Smørgrav 	verbose(VERB_ALGO, "outnettcp cb");
449b7579f77SDag-Erling Smørgrav 	if(error != NETEVENT_NOERROR) {
450b7579f77SDag-Erling Smørgrav 		verbose(VERB_QUERY, "outnettcp got tcp error %d", error);
451b7579f77SDag-Erling Smørgrav 		/* pass error below and exit */
452b7579f77SDag-Erling Smørgrav 	} else {
453b7579f77SDag-Erling Smørgrav 		/* check ID */
45417d15b25SDag-Erling Smørgrav 		if(sldns_buffer_limit(c->buffer) < sizeof(uint16_t) ||
45517d15b25SDag-Erling Smørgrav 			LDNS_ID_WIRE(sldns_buffer_begin(c->buffer))!=pend->id) {
456b7579f77SDag-Erling Smørgrav 			log_addr(VERB_QUERY,
457b7579f77SDag-Erling Smørgrav 				"outnettcp: bad ID in reply, from:",
458b7579f77SDag-Erling Smørgrav 				&pend->query->addr, pend->query->addrlen);
459b7579f77SDag-Erling Smørgrav 			error = NETEVENT_CLOSED;
460b7579f77SDag-Erling Smørgrav 		}
461b7579f77SDag-Erling Smørgrav 	}
462b7579f77SDag-Erling Smørgrav 	fptr_ok(fptr_whitelist_pending_tcp(pend->query->cb));
463b7579f77SDag-Erling Smørgrav 	(void)(*pend->query->cb)(c, pend->query->cb_arg, error, reply_info);
4648a384985SDag-Erling Smørgrav 	decommission_pending_tcp(outnet, pend);
465b7579f77SDag-Erling Smørgrav 	return 0;
466b7579f77SDag-Erling Smørgrav }
467b7579f77SDag-Erling Smørgrav 
468b7579f77SDag-Erling Smørgrav /** lower use count on pc, see if it can be closed */
469b7579f77SDag-Erling Smørgrav static void
470b7579f77SDag-Erling Smørgrav portcomm_loweruse(struct outside_network* outnet, struct port_comm* pc)
471b7579f77SDag-Erling Smørgrav {
472b7579f77SDag-Erling Smørgrav 	struct port_if* pif;
473b7579f77SDag-Erling Smørgrav 	pc->num_outstanding--;
474b7579f77SDag-Erling Smørgrav 	if(pc->num_outstanding > 0) {
475b7579f77SDag-Erling Smørgrav 		return;
476b7579f77SDag-Erling Smørgrav 	}
477b7579f77SDag-Erling Smørgrav 	/* close it and replace in unused list */
478b7579f77SDag-Erling Smørgrav 	verbose(VERB_ALGO, "close of port %d", pc->number);
479b7579f77SDag-Erling Smørgrav 	comm_point_close(pc->cp);
480b7579f77SDag-Erling Smørgrav 	pif = pc->pif;
481b7579f77SDag-Erling Smørgrav 	log_assert(pif->inuse > 0);
482b7579f77SDag-Erling Smørgrav 	pif->avail_ports[pif->avail_total - pif->inuse] = pc->number;
483b7579f77SDag-Erling Smørgrav 	pif->inuse--;
484b7579f77SDag-Erling Smørgrav 	pif->out[pc->index] = pif->out[pif->inuse];
485b7579f77SDag-Erling Smørgrav 	pif->out[pc->index]->index = pc->index;
486b7579f77SDag-Erling Smørgrav 	pc->next = outnet->unused_fds;
487b7579f77SDag-Erling Smørgrav 	outnet->unused_fds = pc;
488b7579f77SDag-Erling Smørgrav }
489b7579f77SDag-Erling Smørgrav 
490b7579f77SDag-Erling Smørgrav /** try to send waiting UDP queries */
491b7579f77SDag-Erling Smørgrav static void
492b7579f77SDag-Erling Smørgrav outnet_send_wait_udp(struct outside_network* outnet)
493b7579f77SDag-Erling Smørgrav {
494b7579f77SDag-Erling Smørgrav 	struct pending* pend;
495b7579f77SDag-Erling Smørgrav 	/* process waiting queries */
496b7579f77SDag-Erling Smørgrav 	while(outnet->udp_wait_first && outnet->unused_fds
497b7579f77SDag-Erling Smørgrav 		&& !outnet->want_to_quit) {
498b7579f77SDag-Erling Smørgrav 		pend = outnet->udp_wait_first;
499b7579f77SDag-Erling Smørgrav 		outnet->udp_wait_first = pend->next_waiting;
500b7579f77SDag-Erling Smørgrav 		if(!pend->next_waiting) outnet->udp_wait_last = NULL;
50117d15b25SDag-Erling Smørgrav 		sldns_buffer_clear(outnet->udp_buff);
50217d15b25SDag-Erling Smørgrav 		sldns_buffer_write(outnet->udp_buff, pend->pkt, pend->pkt_len);
50317d15b25SDag-Erling Smørgrav 		sldns_buffer_flip(outnet->udp_buff);
504b7579f77SDag-Erling Smørgrav 		free(pend->pkt); /* freeing now makes get_mem correct */
505b7579f77SDag-Erling Smørgrav 		pend->pkt = NULL;
506b7579f77SDag-Erling Smørgrav 		pend->pkt_len = 0;
507ff825849SDag-Erling Smørgrav 		if(!randomize_and_send_udp(pend, outnet->udp_buff,
508b7579f77SDag-Erling Smørgrav 			pend->timeout)) {
509b7579f77SDag-Erling Smørgrav 			/* callback error on pending */
51017d15b25SDag-Erling Smørgrav 			if(pend->cb) {
511b7579f77SDag-Erling Smørgrav 				fptr_ok(fptr_whitelist_pending_udp(pend->cb));
512b7579f77SDag-Erling Smørgrav 				(void)(*pend->cb)(outnet->unused_fds->cp, pend->cb_arg,
513b7579f77SDag-Erling Smørgrav 					NETEVENT_CLOSED, NULL);
51417d15b25SDag-Erling Smørgrav 			}
515b7579f77SDag-Erling Smørgrav 			pending_delete(outnet, pend);
516b7579f77SDag-Erling Smørgrav 		}
517b7579f77SDag-Erling Smørgrav 	}
518b7579f77SDag-Erling Smørgrav }
519b7579f77SDag-Erling Smørgrav 
520b7579f77SDag-Erling Smørgrav int
521b7579f77SDag-Erling Smørgrav outnet_udp_cb(struct comm_point* c, void* arg, int error,
522b7579f77SDag-Erling Smørgrav 	struct comm_reply *reply_info)
523b7579f77SDag-Erling Smørgrav {
524b7579f77SDag-Erling Smørgrav 	struct outside_network* outnet = (struct outside_network*)arg;
525b7579f77SDag-Erling Smørgrav 	struct pending key;
526b7579f77SDag-Erling Smørgrav 	struct pending* p;
527b7579f77SDag-Erling Smørgrav 	verbose(VERB_ALGO, "answer cb");
528b7579f77SDag-Erling Smørgrav 
529b7579f77SDag-Erling Smørgrav 	if(error != NETEVENT_NOERROR) {
530b7579f77SDag-Erling Smørgrav 		verbose(VERB_QUERY, "outnetudp got udp error %d", error);
531b7579f77SDag-Erling Smørgrav 		return 0;
532b7579f77SDag-Erling Smørgrav 	}
53317d15b25SDag-Erling Smørgrav 	if(sldns_buffer_limit(c->buffer) < LDNS_HEADER_SIZE) {
534b7579f77SDag-Erling Smørgrav 		verbose(VERB_QUERY, "outnetudp udp too short");
535b7579f77SDag-Erling Smørgrav 		return 0;
536b7579f77SDag-Erling Smørgrav 	}
537b7579f77SDag-Erling Smørgrav 	log_assert(reply_info);
538b7579f77SDag-Erling Smørgrav 
539b7579f77SDag-Erling Smørgrav 	/* setup lookup key */
54017d15b25SDag-Erling Smørgrav 	key.id = (unsigned)LDNS_ID_WIRE(sldns_buffer_begin(c->buffer));
541b7579f77SDag-Erling Smørgrav 	memcpy(&key.addr, &reply_info->addr, reply_info->addrlen);
542b7579f77SDag-Erling Smørgrav 	key.addrlen = reply_info->addrlen;
543b7579f77SDag-Erling Smørgrav 	verbose(VERB_ALGO, "Incoming reply id = %4.4x", key.id);
544b7579f77SDag-Erling Smørgrav 	log_addr(VERB_ALGO, "Incoming reply addr =",
545b7579f77SDag-Erling Smørgrav 		&reply_info->addr, reply_info->addrlen);
546b7579f77SDag-Erling Smørgrav 
547b7579f77SDag-Erling Smørgrav 	/* find it, see if this thing is a valid query response */
548b7579f77SDag-Erling Smørgrav 	verbose(VERB_ALGO, "lookup size is %d entries", (int)outnet->pending->count);
549b7579f77SDag-Erling Smørgrav 	p = (struct pending*)rbtree_search(outnet->pending, &key);
550b7579f77SDag-Erling Smørgrav 	if(!p) {
551b7579f77SDag-Erling Smørgrav 		verbose(VERB_QUERY, "received unwanted or unsolicited udp reply dropped.");
552b7579f77SDag-Erling Smørgrav 		log_buf(VERB_ALGO, "dropped message", c->buffer);
553b7579f77SDag-Erling Smørgrav 		outnet->unwanted_replies++;
554b7579f77SDag-Erling Smørgrav 		if(outnet->unwanted_threshold && ++outnet->unwanted_total
555b7579f77SDag-Erling Smørgrav 			>= outnet->unwanted_threshold) {
556b7579f77SDag-Erling Smørgrav 			log_warn("unwanted reply total reached threshold (%u)"
557b7579f77SDag-Erling Smørgrav 				" you may be under attack."
558b7579f77SDag-Erling Smørgrav 				" defensive action: clearing the cache",
559b7579f77SDag-Erling Smørgrav 				(unsigned)outnet->unwanted_threshold);
560b7579f77SDag-Erling Smørgrav 			fptr_ok(fptr_whitelist_alloc_cleanup(
561b7579f77SDag-Erling Smørgrav 				outnet->unwanted_action));
562b7579f77SDag-Erling Smørgrav 			(*outnet->unwanted_action)(outnet->unwanted_param);
563b7579f77SDag-Erling Smørgrav 			outnet->unwanted_total = 0;
564b7579f77SDag-Erling Smørgrav 		}
565b7579f77SDag-Erling Smørgrav 		return 0;
566b7579f77SDag-Erling Smørgrav 	}
567b7579f77SDag-Erling Smørgrav 
568b7579f77SDag-Erling Smørgrav 	verbose(VERB_ALGO, "received udp reply.");
569b7579f77SDag-Erling Smørgrav 	log_buf(VERB_ALGO, "udp message", c->buffer);
570b7579f77SDag-Erling Smørgrav 	if(p->pc->cp != c) {
571b7579f77SDag-Erling Smørgrav 		verbose(VERB_QUERY, "received reply id,addr on wrong port. "
572b7579f77SDag-Erling Smørgrav 			"dropped.");
573b7579f77SDag-Erling Smørgrav 		outnet->unwanted_replies++;
574b7579f77SDag-Erling Smørgrav 		if(outnet->unwanted_threshold && ++outnet->unwanted_total
575b7579f77SDag-Erling Smørgrav 			>= outnet->unwanted_threshold) {
576b7579f77SDag-Erling Smørgrav 			log_warn("unwanted reply total reached threshold (%u)"
577b7579f77SDag-Erling Smørgrav 				" you may be under attack."
578b7579f77SDag-Erling Smørgrav 				" defensive action: clearing the cache",
579b7579f77SDag-Erling Smørgrav 				(unsigned)outnet->unwanted_threshold);
580b7579f77SDag-Erling Smørgrav 			fptr_ok(fptr_whitelist_alloc_cleanup(
581b7579f77SDag-Erling Smørgrav 				outnet->unwanted_action));
582b7579f77SDag-Erling Smørgrav 			(*outnet->unwanted_action)(outnet->unwanted_param);
583b7579f77SDag-Erling Smørgrav 			outnet->unwanted_total = 0;
584b7579f77SDag-Erling Smørgrav 		}
585b7579f77SDag-Erling Smørgrav 		return 0;
586b7579f77SDag-Erling Smørgrav 	}
587b7579f77SDag-Erling Smørgrav 	comm_timer_disable(p->timer);
588b7579f77SDag-Erling Smørgrav 	verbose(VERB_ALGO, "outnet handle udp reply");
589b7579f77SDag-Erling Smørgrav 	/* delete from tree first in case callback creates a retry */
590b7579f77SDag-Erling Smørgrav 	(void)rbtree_delete(outnet->pending, p->node.key);
59117d15b25SDag-Erling Smørgrav 	if(p->cb) {
592b7579f77SDag-Erling Smørgrav 		fptr_ok(fptr_whitelist_pending_udp(p->cb));
593b7579f77SDag-Erling Smørgrav 		(void)(*p->cb)(p->pc->cp, p->cb_arg, NETEVENT_NOERROR, reply_info);
59417d15b25SDag-Erling Smørgrav 	}
595b7579f77SDag-Erling Smørgrav 	portcomm_loweruse(outnet, p->pc);
596b7579f77SDag-Erling Smørgrav 	pending_delete(NULL, p);
597b7579f77SDag-Erling Smørgrav 	outnet_send_wait_udp(outnet);
598b7579f77SDag-Erling Smørgrav 	return 0;
599b7579f77SDag-Erling Smørgrav }
600b7579f77SDag-Erling Smørgrav 
601b7579f77SDag-Erling Smørgrav /** calculate number of ip4 and ip6 interfaces*/
602b7579f77SDag-Erling Smørgrav static void
603b7579f77SDag-Erling Smørgrav calc_num46(char** ifs, int num_ifs, int do_ip4, int do_ip6,
604b7579f77SDag-Erling Smørgrav 	int* num_ip4, int* num_ip6)
605b7579f77SDag-Erling Smørgrav {
606b7579f77SDag-Erling Smørgrav 	int i;
607b7579f77SDag-Erling Smørgrav 	*num_ip4 = 0;
608b7579f77SDag-Erling Smørgrav 	*num_ip6 = 0;
609b7579f77SDag-Erling Smørgrav 	if(num_ifs <= 0) {
610b7579f77SDag-Erling Smørgrav 		if(do_ip4)
611b7579f77SDag-Erling Smørgrav 			*num_ip4 = 1;
612b7579f77SDag-Erling Smørgrav 		if(do_ip6)
613b7579f77SDag-Erling Smørgrav 			*num_ip6 = 1;
614b7579f77SDag-Erling Smørgrav 		return;
615b7579f77SDag-Erling Smørgrav 	}
616b7579f77SDag-Erling Smørgrav 	for(i=0; i<num_ifs; i++)
617b7579f77SDag-Erling Smørgrav 	{
618b7579f77SDag-Erling Smørgrav 		if(str_is_ip6(ifs[i])) {
619b7579f77SDag-Erling Smørgrav 			if(do_ip6)
620b7579f77SDag-Erling Smørgrav 				(*num_ip6)++;
621b7579f77SDag-Erling Smørgrav 		} else {
622b7579f77SDag-Erling Smørgrav 			if(do_ip4)
623b7579f77SDag-Erling Smørgrav 				(*num_ip4)++;
624b7579f77SDag-Erling Smørgrav 		}
625b7579f77SDag-Erling Smørgrav 	}
626b7579f77SDag-Erling Smørgrav 
627b7579f77SDag-Erling Smørgrav }
628b7579f77SDag-Erling Smørgrav 
629b7579f77SDag-Erling Smørgrav void
63017d15b25SDag-Erling Smørgrav pending_udp_timer_delay_cb(void* arg)
63117d15b25SDag-Erling Smørgrav {
63217d15b25SDag-Erling Smørgrav 	struct pending* p = (struct pending*)arg;
63317d15b25SDag-Erling Smørgrav 	struct outside_network* outnet = p->outnet;
63417d15b25SDag-Erling Smørgrav 	verbose(VERB_ALGO, "timeout udp with delay");
63517d15b25SDag-Erling Smørgrav 	portcomm_loweruse(outnet, p->pc);
63617d15b25SDag-Erling Smørgrav 	pending_delete(outnet, p);
63717d15b25SDag-Erling Smørgrav 	outnet_send_wait_udp(outnet);
63817d15b25SDag-Erling Smørgrav }
63917d15b25SDag-Erling Smørgrav 
64017d15b25SDag-Erling Smørgrav void
641b7579f77SDag-Erling Smørgrav pending_udp_timer_cb(void *arg)
642b7579f77SDag-Erling Smørgrav {
643b7579f77SDag-Erling Smørgrav 	struct pending* p = (struct pending*)arg;
644b7579f77SDag-Erling Smørgrav 	struct outside_network* outnet = p->outnet;
645b7579f77SDag-Erling Smørgrav 	/* it timed out */
646b7579f77SDag-Erling Smørgrav 	verbose(VERB_ALGO, "timeout udp");
64717d15b25SDag-Erling Smørgrav 	if(p->cb) {
648b7579f77SDag-Erling Smørgrav 		fptr_ok(fptr_whitelist_pending_udp(p->cb));
649b7579f77SDag-Erling Smørgrav 		(void)(*p->cb)(p->pc->cp, p->cb_arg, NETEVENT_TIMEOUT, NULL);
65017d15b25SDag-Erling Smørgrav 	}
65117d15b25SDag-Erling Smørgrav 	/* if delayclose, keep port open for a longer time.
65217d15b25SDag-Erling Smørgrav 	 * But if the udpwaitlist exists, then we are struggling to
65317d15b25SDag-Erling Smørgrav 	 * keep up with demand for sockets, so do not wait, but service
65417d15b25SDag-Erling Smørgrav 	 * the customer (customer service more important than portICMPs) */
65517d15b25SDag-Erling Smørgrav 	if(outnet->delayclose && !outnet->udp_wait_first) {
65617d15b25SDag-Erling Smørgrav 		p->cb = NULL;
65717d15b25SDag-Erling Smørgrav 		p->timer->callback = &pending_udp_timer_delay_cb;
65817d15b25SDag-Erling Smørgrav 		comm_timer_set(p->timer, &outnet->delay_tv);
65917d15b25SDag-Erling Smørgrav 		return;
66017d15b25SDag-Erling Smørgrav 	}
661b7579f77SDag-Erling Smørgrav 	portcomm_loweruse(outnet, p->pc);
662b7579f77SDag-Erling Smørgrav 	pending_delete(outnet, p);
663b7579f77SDag-Erling Smørgrav 	outnet_send_wait_udp(outnet);
664b7579f77SDag-Erling Smørgrav }
665b7579f77SDag-Erling Smørgrav 
666b7579f77SDag-Erling Smørgrav /** create pending_tcp buffers */
667b7579f77SDag-Erling Smørgrav static int
668b7579f77SDag-Erling Smørgrav create_pending_tcp(struct outside_network* outnet, size_t bufsize)
669b7579f77SDag-Erling Smørgrav {
670b7579f77SDag-Erling Smørgrav 	size_t i;
671b7579f77SDag-Erling Smørgrav 	if(outnet->num_tcp == 0)
672b7579f77SDag-Erling Smørgrav 		return 1; /* no tcp needed, nothing to do */
673b7579f77SDag-Erling Smørgrav 	if(!(outnet->tcp_conns = (struct pending_tcp **)calloc(
674b7579f77SDag-Erling Smørgrav 			outnet->num_tcp, sizeof(struct pending_tcp*))))
675b7579f77SDag-Erling Smørgrav 		return 0;
676b7579f77SDag-Erling Smørgrav 	for(i=0; i<outnet->num_tcp; i++) {
677b7579f77SDag-Erling Smørgrav 		if(!(outnet->tcp_conns[i] = (struct pending_tcp*)calloc(1,
678b7579f77SDag-Erling Smørgrav 			sizeof(struct pending_tcp))))
679b7579f77SDag-Erling Smørgrav 			return 0;
680b7579f77SDag-Erling Smørgrav 		outnet->tcp_conns[i]->next_free = outnet->tcp_free;
681b7579f77SDag-Erling Smørgrav 		outnet->tcp_free = outnet->tcp_conns[i];
682b7579f77SDag-Erling Smørgrav 		outnet->tcp_conns[i]->c = comm_point_create_tcp_out(
683b7579f77SDag-Erling Smørgrav 			outnet->base, bufsize, outnet_tcp_cb,
684b7579f77SDag-Erling Smørgrav 			outnet->tcp_conns[i]);
685b7579f77SDag-Erling Smørgrav 		if(!outnet->tcp_conns[i]->c)
686b7579f77SDag-Erling Smørgrav 			return 0;
687b7579f77SDag-Erling Smørgrav 	}
688b7579f77SDag-Erling Smørgrav 	return 1;
689b7579f77SDag-Erling Smørgrav }
690b7579f77SDag-Erling Smørgrav 
691b7579f77SDag-Erling Smørgrav /** setup an outgoing interface, ready address */
692b7579f77SDag-Erling Smørgrav static int setup_if(struct port_if* pif, const char* addrstr,
693b7579f77SDag-Erling Smørgrav 	int* avail, int numavail, size_t numfd)
694b7579f77SDag-Erling Smørgrav {
695b7579f77SDag-Erling Smørgrav 	pif->avail_total = numavail;
696b7579f77SDag-Erling Smørgrav 	pif->avail_ports = (int*)memdup(avail, (size_t)numavail*sizeof(int));
697b7579f77SDag-Erling Smørgrav 	if(!pif->avail_ports)
698b7579f77SDag-Erling Smørgrav 		return 0;
699b5663de9SDag-Erling Smørgrav 	if(!ipstrtoaddr(addrstr, UNBOUND_DNS_PORT, &pif->addr, &pif->addrlen) &&
700b5663de9SDag-Erling Smørgrav 	   !netblockstrtoaddr(addrstr, UNBOUND_DNS_PORT,
701b5663de9SDag-Erling Smørgrav 			      &pif->addr, &pif->addrlen, &pif->pfxlen))
702b7579f77SDag-Erling Smørgrav 		return 0;
703b7579f77SDag-Erling Smørgrav 	pif->maxout = (int)numfd;
704b7579f77SDag-Erling Smørgrav 	pif->inuse = 0;
705b7579f77SDag-Erling Smørgrav 	pif->out = (struct port_comm**)calloc(numfd,
706b7579f77SDag-Erling Smørgrav 		sizeof(struct port_comm*));
707b7579f77SDag-Erling Smørgrav 	if(!pif->out)
708b7579f77SDag-Erling Smørgrav 		return 0;
709b7579f77SDag-Erling Smørgrav 	return 1;
710b7579f77SDag-Erling Smørgrav }
711b7579f77SDag-Erling Smørgrav 
712b7579f77SDag-Erling Smørgrav struct outside_network*
713b7579f77SDag-Erling Smørgrav outside_network_create(struct comm_base *base, size_t bufsize,
714b7579f77SDag-Erling Smørgrav 	size_t num_ports, char** ifs, int num_ifs, int do_ip4,
715b7579f77SDag-Erling Smørgrav 	int do_ip6, size_t num_tcp, struct infra_cache* infra,
716b7579f77SDag-Erling Smørgrav 	struct ub_randstate* rnd, int use_caps_for_id, int* availports,
717f61ef7f6SDag-Erling Smørgrav 	int numavailports, size_t unwanted_threshold, int tcp_mss,
718b7579f77SDag-Erling Smørgrav 	void (*unwanted_action)(void*), void* unwanted_param, int do_udp,
719ff825849SDag-Erling Smørgrav 	void* sslctx, int delayclose, struct dt_env* dtenv)
720b7579f77SDag-Erling Smørgrav {
721b7579f77SDag-Erling Smørgrav 	struct outside_network* outnet = (struct outside_network*)
722b7579f77SDag-Erling Smørgrav 		calloc(1, sizeof(struct outside_network));
723b7579f77SDag-Erling Smørgrav 	size_t k;
724b7579f77SDag-Erling Smørgrav 	if(!outnet) {
725b7579f77SDag-Erling Smørgrav 		log_err("malloc failed");
726b7579f77SDag-Erling Smørgrav 		return NULL;
727b7579f77SDag-Erling Smørgrav 	}
728b7579f77SDag-Erling Smørgrav 	comm_base_timept(base, &outnet->now_secs, &outnet->now_tv);
729b7579f77SDag-Erling Smørgrav 	outnet->base = base;
730b7579f77SDag-Erling Smørgrav 	outnet->num_tcp = num_tcp;
731ff825849SDag-Erling Smørgrav 	outnet->num_tcp_outgoing = 0;
732b7579f77SDag-Erling Smørgrav 	outnet->infra = infra;
733b7579f77SDag-Erling Smørgrav 	outnet->rnd = rnd;
734b7579f77SDag-Erling Smørgrav 	outnet->sslctx = sslctx;
735ff825849SDag-Erling Smørgrav #ifdef USE_DNSTAP
736ff825849SDag-Erling Smørgrav 	outnet->dtenv = dtenv;
737ff825849SDag-Erling Smørgrav #else
738ff825849SDag-Erling Smørgrav 	(void)dtenv;
739ff825849SDag-Erling Smørgrav #endif
740b7579f77SDag-Erling Smørgrav 	outnet->svcd_overhead = 0;
741b7579f77SDag-Erling Smørgrav 	outnet->want_to_quit = 0;
742b7579f77SDag-Erling Smørgrav 	outnet->unwanted_threshold = unwanted_threshold;
743b7579f77SDag-Erling Smørgrav 	outnet->unwanted_action = unwanted_action;
744b7579f77SDag-Erling Smørgrav 	outnet->unwanted_param = unwanted_param;
745b7579f77SDag-Erling Smørgrav 	outnet->use_caps_for_id = use_caps_for_id;
746b7579f77SDag-Erling Smørgrav 	outnet->do_udp = do_udp;
747f61ef7f6SDag-Erling Smørgrav 	outnet->tcp_mss = tcp_mss;
74817d15b25SDag-Erling Smørgrav #ifndef S_SPLINT_S
74917d15b25SDag-Erling Smørgrav 	if(delayclose) {
75017d15b25SDag-Erling Smørgrav 		outnet->delayclose = 1;
75117d15b25SDag-Erling Smørgrav 		outnet->delay_tv.tv_sec = delayclose/1000;
75217d15b25SDag-Erling Smørgrav 		outnet->delay_tv.tv_usec = (delayclose%1000)*1000;
75317d15b25SDag-Erling Smørgrav 	}
75417d15b25SDag-Erling Smørgrav #endif
755b7579f77SDag-Erling Smørgrav 	if(numavailports == 0) {
756b7579f77SDag-Erling Smørgrav 		log_err("no outgoing ports available");
757b7579f77SDag-Erling Smørgrav 		outside_network_delete(outnet);
758b7579f77SDag-Erling Smørgrav 		return NULL;
759b7579f77SDag-Erling Smørgrav 	}
760b7579f77SDag-Erling Smørgrav #ifndef INET6
761b7579f77SDag-Erling Smørgrav 	do_ip6 = 0;
762b7579f77SDag-Erling Smørgrav #endif
763b7579f77SDag-Erling Smørgrav 	calc_num46(ifs, num_ifs, do_ip4, do_ip6,
764b7579f77SDag-Erling Smørgrav 		&outnet->num_ip4, &outnet->num_ip6);
765b7579f77SDag-Erling Smørgrav 	if(outnet->num_ip4 != 0) {
766b7579f77SDag-Erling Smørgrav 		if(!(outnet->ip4_ifs = (struct port_if*)calloc(
767b7579f77SDag-Erling Smørgrav 			(size_t)outnet->num_ip4, sizeof(struct port_if)))) {
768b7579f77SDag-Erling Smørgrav 			log_err("malloc failed");
769b7579f77SDag-Erling Smørgrav 			outside_network_delete(outnet);
770b7579f77SDag-Erling Smørgrav 			return NULL;
771b7579f77SDag-Erling Smørgrav 		}
772b7579f77SDag-Erling Smørgrav 	}
773b7579f77SDag-Erling Smørgrav 	if(outnet->num_ip6 != 0) {
774b7579f77SDag-Erling Smørgrav 		if(!(outnet->ip6_ifs = (struct port_if*)calloc(
775b7579f77SDag-Erling Smørgrav 			(size_t)outnet->num_ip6, sizeof(struct port_if)))) {
776b7579f77SDag-Erling Smørgrav 			log_err("malloc failed");
777b7579f77SDag-Erling Smørgrav 			outside_network_delete(outnet);
778b7579f77SDag-Erling Smørgrav 			return NULL;
779b7579f77SDag-Erling Smørgrav 		}
780b7579f77SDag-Erling Smørgrav 	}
78117d15b25SDag-Erling Smørgrav 	if(	!(outnet->udp_buff = sldns_buffer_new(bufsize)) ||
782b7579f77SDag-Erling Smørgrav 		!(outnet->pending = rbtree_create(pending_cmp)) ||
783b7579f77SDag-Erling Smørgrav 		!(outnet->serviced = rbtree_create(serviced_cmp)) ||
784b7579f77SDag-Erling Smørgrav 		!create_pending_tcp(outnet, bufsize)) {
785b7579f77SDag-Erling Smørgrav 		log_err("malloc failed");
786b7579f77SDag-Erling Smørgrav 		outside_network_delete(outnet);
787b7579f77SDag-Erling Smørgrav 		return NULL;
788b7579f77SDag-Erling Smørgrav 	}
789b7579f77SDag-Erling Smørgrav 
790b7579f77SDag-Erling Smørgrav 	/* allocate commpoints */
791b7579f77SDag-Erling Smørgrav 	for(k=0; k<num_ports; k++) {
792b7579f77SDag-Erling Smørgrav 		struct port_comm* pc;
793b7579f77SDag-Erling Smørgrav 		pc = (struct port_comm*)calloc(1, sizeof(*pc));
794b7579f77SDag-Erling Smørgrav 		if(!pc) {
795b7579f77SDag-Erling Smørgrav 			log_err("malloc failed");
796b7579f77SDag-Erling Smørgrav 			outside_network_delete(outnet);
797b7579f77SDag-Erling Smørgrav 			return NULL;
798b7579f77SDag-Erling Smørgrav 		}
799b7579f77SDag-Erling Smørgrav 		pc->cp = comm_point_create_udp(outnet->base, -1,
800b7579f77SDag-Erling Smørgrav 			outnet->udp_buff, outnet_udp_cb, outnet);
801b7579f77SDag-Erling Smørgrav 		if(!pc->cp) {
802b7579f77SDag-Erling Smørgrav 			log_err("malloc failed");
803b7579f77SDag-Erling Smørgrav 			free(pc);
804b7579f77SDag-Erling Smørgrav 			outside_network_delete(outnet);
805b7579f77SDag-Erling Smørgrav 			return NULL;
806b7579f77SDag-Erling Smørgrav 		}
807b7579f77SDag-Erling Smørgrav 		pc->next = outnet->unused_fds;
808b7579f77SDag-Erling Smørgrav 		outnet->unused_fds = pc;
809b7579f77SDag-Erling Smørgrav 	}
810b7579f77SDag-Erling Smørgrav 
811b7579f77SDag-Erling Smørgrav 	/* allocate interfaces */
812b7579f77SDag-Erling Smørgrav 	if(num_ifs == 0) {
813b7579f77SDag-Erling Smørgrav 		if(do_ip4 && !setup_if(&outnet->ip4_ifs[0], "0.0.0.0",
814b7579f77SDag-Erling Smørgrav 			availports, numavailports, num_ports)) {
815b7579f77SDag-Erling Smørgrav 			log_err("malloc failed");
816b7579f77SDag-Erling Smørgrav 			outside_network_delete(outnet);
817b7579f77SDag-Erling Smørgrav 			return NULL;
818b7579f77SDag-Erling Smørgrav 		}
819b7579f77SDag-Erling Smørgrav 		if(do_ip6 && !setup_if(&outnet->ip6_ifs[0], "::",
820b7579f77SDag-Erling Smørgrav 			availports, numavailports, num_ports)) {
821b7579f77SDag-Erling Smørgrav 			log_err("malloc failed");
822b7579f77SDag-Erling Smørgrav 			outside_network_delete(outnet);
823b7579f77SDag-Erling Smørgrav 			return NULL;
824b7579f77SDag-Erling Smørgrav 		}
825b7579f77SDag-Erling Smørgrav 	} else {
826b7579f77SDag-Erling Smørgrav 		size_t done_4 = 0, done_6 = 0;
827b7579f77SDag-Erling Smørgrav 		int i;
828b7579f77SDag-Erling Smørgrav 		for(i=0; i<num_ifs; i++) {
829b7579f77SDag-Erling Smørgrav 			if(str_is_ip6(ifs[i]) && do_ip6) {
830b7579f77SDag-Erling Smørgrav 				if(!setup_if(&outnet->ip6_ifs[done_6], ifs[i],
831b7579f77SDag-Erling Smørgrav 					availports, numavailports, num_ports)){
832b7579f77SDag-Erling Smørgrav 					log_err("malloc failed");
833b7579f77SDag-Erling Smørgrav 					outside_network_delete(outnet);
834b7579f77SDag-Erling Smørgrav 					return NULL;
835b7579f77SDag-Erling Smørgrav 				}
836b7579f77SDag-Erling Smørgrav 				done_6++;
837b7579f77SDag-Erling Smørgrav 			}
838b7579f77SDag-Erling Smørgrav 			if(!str_is_ip6(ifs[i]) && do_ip4) {
839b7579f77SDag-Erling Smørgrav 				if(!setup_if(&outnet->ip4_ifs[done_4], ifs[i],
840b7579f77SDag-Erling Smørgrav 					availports, numavailports, num_ports)){
841b7579f77SDag-Erling Smørgrav 					log_err("malloc failed");
842b7579f77SDag-Erling Smørgrav 					outside_network_delete(outnet);
843b7579f77SDag-Erling Smørgrav 					return NULL;
844b7579f77SDag-Erling Smørgrav 				}
845b7579f77SDag-Erling Smørgrav 				done_4++;
846b7579f77SDag-Erling Smørgrav 			}
847b7579f77SDag-Erling Smørgrav 		}
848b7579f77SDag-Erling Smørgrav 	}
849b7579f77SDag-Erling Smørgrav 	return outnet;
850b7579f77SDag-Erling Smørgrav }
851b7579f77SDag-Erling Smørgrav 
852b7579f77SDag-Erling Smørgrav /** helper pending delete */
853b7579f77SDag-Erling Smørgrav static void
8543005e0a3SDag-Erling Smørgrav pending_node_del(rbnode_type* node, void* arg)
855b7579f77SDag-Erling Smørgrav {
856b7579f77SDag-Erling Smørgrav 	struct pending* pend = (struct pending*)node;
857b7579f77SDag-Erling Smørgrav 	struct outside_network* outnet = (struct outside_network*)arg;
858b7579f77SDag-Erling Smørgrav 	pending_delete(outnet, pend);
859b7579f77SDag-Erling Smørgrav }
860b7579f77SDag-Erling Smørgrav 
861b7579f77SDag-Erling Smørgrav /** helper serviced delete */
862b7579f77SDag-Erling Smørgrav static void
8633005e0a3SDag-Erling Smørgrav serviced_node_del(rbnode_type* node, void* ATTR_UNUSED(arg))
864b7579f77SDag-Erling Smørgrav {
865b7579f77SDag-Erling Smørgrav 	struct serviced_query* sq = (struct serviced_query*)node;
866b7579f77SDag-Erling Smørgrav 	struct service_callback* p = sq->cblist, *np;
867b7579f77SDag-Erling Smørgrav 	free(sq->qbuf);
868b7579f77SDag-Erling Smørgrav 	free(sq->zone);
8690fb34990SDag-Erling Smørgrav 	free(sq->tls_auth_name);
870e2d15004SDag-Erling Smørgrav 	edns_opt_list_free(sq->opt_list);
871b7579f77SDag-Erling Smørgrav 	while(p) {
872b7579f77SDag-Erling Smørgrav 		np = p->next;
873b7579f77SDag-Erling Smørgrav 		free(p);
874b7579f77SDag-Erling Smørgrav 		p = np;
875b7579f77SDag-Erling Smørgrav 	}
876b7579f77SDag-Erling Smørgrav 	free(sq);
877b7579f77SDag-Erling Smørgrav }
878b7579f77SDag-Erling Smørgrav 
879b7579f77SDag-Erling Smørgrav void
880b7579f77SDag-Erling Smørgrav outside_network_quit_prepare(struct outside_network* outnet)
881b7579f77SDag-Erling Smørgrav {
882b7579f77SDag-Erling Smørgrav 	if(!outnet)
883b7579f77SDag-Erling Smørgrav 		return;
884b7579f77SDag-Erling Smørgrav 	/* prevent queued items from being sent */
885b7579f77SDag-Erling Smørgrav 	outnet->want_to_quit = 1;
886b7579f77SDag-Erling Smørgrav }
887b7579f77SDag-Erling Smørgrav 
888b7579f77SDag-Erling Smørgrav void
889b7579f77SDag-Erling Smørgrav outside_network_delete(struct outside_network* outnet)
890b7579f77SDag-Erling Smørgrav {
891b7579f77SDag-Erling Smørgrav 	if(!outnet)
892b7579f77SDag-Erling Smørgrav 		return;
893b7579f77SDag-Erling Smørgrav 	outnet->want_to_quit = 1;
894b7579f77SDag-Erling Smørgrav 	/* check every element, since we can be called on malloc error */
895b7579f77SDag-Erling Smørgrav 	if(outnet->pending) {
896b7579f77SDag-Erling Smørgrav 		/* free pending elements, but do no unlink from tree. */
897b7579f77SDag-Erling Smørgrav 		traverse_postorder(outnet->pending, pending_node_del, NULL);
898b7579f77SDag-Erling Smørgrav 		free(outnet->pending);
899b7579f77SDag-Erling Smørgrav 	}
900b7579f77SDag-Erling Smørgrav 	if(outnet->serviced) {
901b7579f77SDag-Erling Smørgrav 		traverse_postorder(outnet->serviced, serviced_node_del, NULL);
902b7579f77SDag-Erling Smørgrav 		free(outnet->serviced);
903b7579f77SDag-Erling Smørgrav 	}
904b7579f77SDag-Erling Smørgrav 	if(outnet->udp_buff)
90517d15b25SDag-Erling Smørgrav 		sldns_buffer_free(outnet->udp_buff);
906b7579f77SDag-Erling Smørgrav 	if(outnet->unused_fds) {
907b7579f77SDag-Erling Smørgrav 		struct port_comm* p = outnet->unused_fds, *np;
908b7579f77SDag-Erling Smørgrav 		while(p) {
909b7579f77SDag-Erling Smørgrav 			np = p->next;
910b7579f77SDag-Erling Smørgrav 			comm_point_delete(p->cp);
911b7579f77SDag-Erling Smørgrav 			free(p);
912b7579f77SDag-Erling Smørgrav 			p = np;
913b7579f77SDag-Erling Smørgrav 		}
914b7579f77SDag-Erling Smørgrav 		outnet->unused_fds = NULL;
915b7579f77SDag-Erling Smørgrav 	}
916b7579f77SDag-Erling Smørgrav 	if(outnet->ip4_ifs) {
917b7579f77SDag-Erling Smørgrav 		int i, k;
918b7579f77SDag-Erling Smørgrav 		for(i=0; i<outnet->num_ip4; i++) {
919b7579f77SDag-Erling Smørgrav 			for(k=0; k<outnet->ip4_ifs[i].inuse; k++) {
920b7579f77SDag-Erling Smørgrav 				struct port_comm* pc = outnet->ip4_ifs[i].
921b7579f77SDag-Erling Smørgrav 					out[k];
922b7579f77SDag-Erling Smørgrav 				comm_point_delete(pc->cp);
923b7579f77SDag-Erling Smørgrav 				free(pc);
924b7579f77SDag-Erling Smørgrav 			}
925b7579f77SDag-Erling Smørgrav 			free(outnet->ip4_ifs[i].avail_ports);
926b7579f77SDag-Erling Smørgrav 			free(outnet->ip4_ifs[i].out);
927b7579f77SDag-Erling Smørgrav 		}
928b7579f77SDag-Erling Smørgrav 		free(outnet->ip4_ifs);
929b7579f77SDag-Erling Smørgrav 	}
930b7579f77SDag-Erling Smørgrav 	if(outnet->ip6_ifs) {
931b7579f77SDag-Erling Smørgrav 		int i, k;
932b7579f77SDag-Erling Smørgrav 		for(i=0; i<outnet->num_ip6; i++) {
933b7579f77SDag-Erling Smørgrav 			for(k=0; k<outnet->ip6_ifs[i].inuse; k++) {
934b7579f77SDag-Erling Smørgrav 				struct port_comm* pc = outnet->ip6_ifs[i].
935b7579f77SDag-Erling Smørgrav 					out[k];
936b7579f77SDag-Erling Smørgrav 				comm_point_delete(pc->cp);
937b7579f77SDag-Erling Smørgrav 				free(pc);
938b7579f77SDag-Erling Smørgrav 			}
939b7579f77SDag-Erling Smørgrav 			free(outnet->ip6_ifs[i].avail_ports);
940b7579f77SDag-Erling Smørgrav 			free(outnet->ip6_ifs[i].out);
941b7579f77SDag-Erling Smørgrav 		}
942b7579f77SDag-Erling Smørgrav 		free(outnet->ip6_ifs);
943b7579f77SDag-Erling Smørgrav 	}
944b7579f77SDag-Erling Smørgrav 	if(outnet->tcp_conns) {
945b7579f77SDag-Erling Smørgrav 		size_t i;
946b7579f77SDag-Erling Smørgrav 		for(i=0; i<outnet->num_tcp; i++)
947b7579f77SDag-Erling Smørgrav 			if(outnet->tcp_conns[i]) {
948b7579f77SDag-Erling Smørgrav 				comm_point_delete(outnet->tcp_conns[i]->c);
949b7579f77SDag-Erling Smørgrav 				waiting_tcp_delete(outnet->tcp_conns[i]->query);
950b7579f77SDag-Erling Smørgrav 				free(outnet->tcp_conns[i]);
951b7579f77SDag-Erling Smørgrav 			}
952b7579f77SDag-Erling Smørgrav 		free(outnet->tcp_conns);
953b7579f77SDag-Erling Smørgrav 	}
954b7579f77SDag-Erling Smørgrav 	if(outnet->tcp_wait_first) {
955b7579f77SDag-Erling Smørgrav 		struct waiting_tcp* p = outnet->tcp_wait_first, *np;
956b7579f77SDag-Erling Smørgrav 		while(p) {
957b7579f77SDag-Erling Smørgrav 			np = p->next_waiting;
958b7579f77SDag-Erling Smørgrav 			waiting_tcp_delete(p);
959b7579f77SDag-Erling Smørgrav 			p = np;
960b7579f77SDag-Erling Smørgrav 		}
961b7579f77SDag-Erling Smørgrav 	}
962b7579f77SDag-Erling Smørgrav 	if(outnet->udp_wait_first) {
963b7579f77SDag-Erling Smørgrav 		struct pending* p = outnet->udp_wait_first, *np;
964b7579f77SDag-Erling Smørgrav 		while(p) {
965b7579f77SDag-Erling Smørgrav 			np = p->next_waiting;
966b7579f77SDag-Erling Smørgrav 			pending_delete(NULL, p);
967b7579f77SDag-Erling Smørgrav 			p = np;
968b7579f77SDag-Erling Smørgrav 		}
969b7579f77SDag-Erling Smørgrav 	}
970b7579f77SDag-Erling Smørgrav 	free(outnet);
971b7579f77SDag-Erling Smørgrav }
972b7579f77SDag-Erling Smørgrav 
973b7579f77SDag-Erling Smørgrav void
974b7579f77SDag-Erling Smørgrav pending_delete(struct outside_network* outnet, struct pending* p)
975b7579f77SDag-Erling Smørgrav {
976b7579f77SDag-Erling Smørgrav 	if(!p)
977b7579f77SDag-Erling Smørgrav 		return;
978b7579f77SDag-Erling Smørgrav 	if(outnet && outnet->udp_wait_first &&
979b7579f77SDag-Erling Smørgrav 		(p->next_waiting || p == outnet->udp_wait_last) ) {
980b7579f77SDag-Erling Smørgrav 		/* delete from waiting list, if it is in the waiting list */
981b7579f77SDag-Erling Smørgrav 		struct pending* prev = NULL, *x = outnet->udp_wait_first;
982b7579f77SDag-Erling Smørgrav 		while(x && x != p) {
983b7579f77SDag-Erling Smørgrav 			prev = x;
984b7579f77SDag-Erling Smørgrav 			x = x->next_waiting;
985b7579f77SDag-Erling Smørgrav 		}
986b7579f77SDag-Erling Smørgrav 		if(x) {
987b7579f77SDag-Erling Smørgrav 			log_assert(x == p);
988b7579f77SDag-Erling Smørgrav 			if(prev)
989b7579f77SDag-Erling Smørgrav 				prev->next_waiting = p->next_waiting;
990b7579f77SDag-Erling Smørgrav 			else	outnet->udp_wait_first = p->next_waiting;
991b7579f77SDag-Erling Smørgrav 			if(outnet->udp_wait_last == p)
992b7579f77SDag-Erling Smørgrav 				outnet->udp_wait_last = prev;
993b7579f77SDag-Erling Smørgrav 		}
994b7579f77SDag-Erling Smørgrav 	}
995b7579f77SDag-Erling Smørgrav 	if(outnet) {
996b7579f77SDag-Erling Smørgrav 		(void)rbtree_delete(outnet->pending, p->node.key);
997b7579f77SDag-Erling Smørgrav 	}
998b7579f77SDag-Erling Smørgrav 	if(p->timer)
999b7579f77SDag-Erling Smørgrav 		comm_timer_delete(p->timer);
1000b7579f77SDag-Erling Smørgrav 	free(p->pkt);
1001b7579f77SDag-Erling Smørgrav 	free(p);
1002b7579f77SDag-Erling Smørgrav }
1003b7579f77SDag-Erling Smørgrav 
1004b5663de9SDag-Erling Smørgrav static void
1005b5663de9SDag-Erling Smørgrav sai6_putrandom(struct sockaddr_in6 *sa, int pfxlen, struct ub_randstate *rnd)
1006b5663de9SDag-Erling Smørgrav {
1007b5663de9SDag-Erling Smørgrav 	int i, last;
1008b5663de9SDag-Erling Smørgrav 	if(!(pfxlen > 0 && pfxlen < 128))
1009b5663de9SDag-Erling Smørgrav 		return;
1010b5663de9SDag-Erling Smørgrav 	for(i = 0; i < (128 - pfxlen) / 8; i++) {
1011b5663de9SDag-Erling Smørgrav 		sa->sin6_addr.s6_addr[15-i] = (uint8_t)ub_random_max(rnd, 256);
1012b5663de9SDag-Erling Smørgrav 	}
1013b5663de9SDag-Erling Smørgrav 	last = pfxlen & 7;
1014b5663de9SDag-Erling Smørgrav 	if(last != 0) {
1015b5663de9SDag-Erling Smørgrav 		sa->sin6_addr.s6_addr[15-i] |=
1016b5663de9SDag-Erling Smørgrav 			((0xFF >> last) & ub_random_max(rnd, 256));
1017b5663de9SDag-Erling Smørgrav 	}
1018b5663de9SDag-Erling Smørgrav }
1019b5663de9SDag-Erling Smørgrav 
1020b7579f77SDag-Erling Smørgrav /**
1021b7579f77SDag-Erling Smørgrav  * Try to open a UDP socket for outgoing communication.
1022b7579f77SDag-Erling Smørgrav  * Sets sockets options as needed.
1023b7579f77SDag-Erling Smørgrav  * @param addr: socket address.
1024b7579f77SDag-Erling Smørgrav  * @param addrlen: length of address.
1025b5663de9SDag-Erling Smørgrav  * @param pfxlen: length of network prefix (for address randomisation).
1026b7579f77SDag-Erling Smørgrav  * @param port: port override for addr.
1027b7579f77SDag-Erling Smørgrav  * @param inuse: if -1 is returned, this bool means the port was in use.
1028b5663de9SDag-Erling Smørgrav  * @param rnd: random state (for address randomisation).
1029b7579f77SDag-Erling Smørgrav  * @return fd or -1
1030b7579f77SDag-Erling Smørgrav  */
1031b7579f77SDag-Erling Smørgrav static int
1032b5663de9SDag-Erling Smørgrav udp_sockport(struct sockaddr_storage* addr, socklen_t addrlen, int pfxlen,
1033b5663de9SDag-Erling Smørgrav 	int port, int* inuse, struct ub_randstate* rnd)
1034b7579f77SDag-Erling Smørgrav {
1035b7579f77SDag-Erling Smørgrav 	int fd, noproto;
1036b7579f77SDag-Erling Smørgrav 	if(addr_is_ip6(addr, addrlen)) {
1037b5663de9SDag-Erling Smørgrav 		int freebind = 0;
1038b5663de9SDag-Erling Smørgrav 		struct sockaddr_in6 sa = *(struct sockaddr_in6*)addr;
1039b5663de9SDag-Erling Smørgrav 		sa.sin6_port = (in_port_t)htons((uint16_t)port);
1040*4c75e3aaSDag-Erling Smørgrav 		sa.sin6_flowinfo = 0;
1041*4c75e3aaSDag-Erling Smørgrav 		sa.sin6_scope_id = 0;
1042b5663de9SDag-Erling Smørgrav 		if(pfxlen != 0) {
1043b5663de9SDag-Erling Smørgrav 			freebind = 1;
1044b5663de9SDag-Erling Smørgrav 			sai6_putrandom(&sa, pfxlen, rnd);
1045b5663de9SDag-Erling Smørgrav 		}
1046b7579f77SDag-Erling Smørgrav 		fd = create_udp_sock(AF_INET6, SOCK_DGRAM,
1047b5663de9SDag-Erling Smørgrav 			(struct sockaddr*)&sa, addrlen, 1, inuse, &noproto,
10483005e0a3SDag-Erling Smørgrav 			0, 0, 0, NULL, 0, freebind, 0);
1049b7579f77SDag-Erling Smørgrav 	} else {
1050b7579f77SDag-Erling Smørgrav 		struct sockaddr_in* sa = (struct sockaddr_in*)addr;
1051b7579f77SDag-Erling Smørgrav 		sa->sin_port = (in_port_t)htons((uint16_t)port);
1052b7579f77SDag-Erling Smørgrav 		fd = create_udp_sock(AF_INET, SOCK_DGRAM,
1053b7579f77SDag-Erling Smørgrav 			(struct sockaddr*)addr, addrlen, 1, inuse, &noproto,
10543005e0a3SDag-Erling Smørgrav 			0, 0, 0, NULL, 0, 0, 0);
1055b7579f77SDag-Erling Smørgrav 	}
1056b7579f77SDag-Erling Smørgrav 	return fd;
1057b7579f77SDag-Erling Smørgrav }
1058b7579f77SDag-Erling Smørgrav 
1059b7579f77SDag-Erling Smørgrav /** Select random ID */
1060b7579f77SDag-Erling Smørgrav static int
1061b7579f77SDag-Erling Smørgrav select_id(struct outside_network* outnet, struct pending* pend,
106217d15b25SDag-Erling Smørgrav 	sldns_buffer* packet)
1063b7579f77SDag-Erling Smørgrav {
1064b7579f77SDag-Erling Smørgrav 	int id_tries = 0;
1065b7579f77SDag-Erling Smørgrav 	pend->id = ((unsigned)ub_random(outnet->rnd)>>8) & 0xffff;
106617d15b25SDag-Erling Smørgrav 	LDNS_ID_SET(sldns_buffer_begin(packet), pend->id);
1067b7579f77SDag-Erling Smørgrav 
1068b7579f77SDag-Erling Smørgrav 	/* insert in tree */
1069b7579f77SDag-Erling Smørgrav 	pend->node.key = pend;
1070b7579f77SDag-Erling Smørgrav 	while(!rbtree_insert(outnet->pending, &pend->node)) {
1071b7579f77SDag-Erling Smørgrav 		/* change ID to avoid collision */
1072b7579f77SDag-Erling Smørgrav 		pend->id = ((unsigned)ub_random(outnet->rnd)>>8) & 0xffff;
107317d15b25SDag-Erling Smørgrav 		LDNS_ID_SET(sldns_buffer_begin(packet), pend->id);
1074b7579f77SDag-Erling Smørgrav 		id_tries++;
1075b7579f77SDag-Erling Smørgrav 		if(id_tries == MAX_ID_RETRY) {
1076b7579f77SDag-Erling Smørgrav 			pend->id=99999; /* non existant ID */
1077b7579f77SDag-Erling Smørgrav 			log_err("failed to generate unique ID, drop msg");
1078b7579f77SDag-Erling Smørgrav 			return 0;
1079b7579f77SDag-Erling Smørgrav 		}
1080b7579f77SDag-Erling Smørgrav 	}
1081b7579f77SDag-Erling Smørgrav 	verbose(VERB_ALGO, "inserted new pending reply id=%4.4x", pend->id);
1082b7579f77SDag-Erling Smørgrav 	return 1;
1083b7579f77SDag-Erling Smørgrav }
1084b7579f77SDag-Erling Smørgrav 
1085b7579f77SDag-Erling Smørgrav /** Select random interface and port */
1086b7579f77SDag-Erling Smørgrav static int
1087b7579f77SDag-Erling Smørgrav select_ifport(struct outside_network* outnet, struct pending* pend,
1088b7579f77SDag-Erling Smørgrav 	int num_if, struct port_if* ifs)
1089b7579f77SDag-Erling Smørgrav {
1090b7579f77SDag-Erling Smørgrav 	int my_if, my_port, fd, portno, inuse, tries=0;
1091b7579f77SDag-Erling Smørgrav 	struct port_if* pif;
1092b7579f77SDag-Erling Smørgrav 	/* randomly select interface and port */
1093b7579f77SDag-Erling Smørgrav 	if(num_if == 0) {
1094b7579f77SDag-Erling Smørgrav 		verbose(VERB_QUERY, "Need to send query but have no "
1095b7579f77SDag-Erling Smørgrav 			"outgoing interfaces of that family");
1096b7579f77SDag-Erling Smørgrav 		return 0;
1097b7579f77SDag-Erling Smørgrav 	}
1098b7579f77SDag-Erling Smørgrav 	log_assert(outnet->unused_fds);
1099b7579f77SDag-Erling Smørgrav 	tries = 0;
1100b7579f77SDag-Erling Smørgrav 	while(1) {
1101b7579f77SDag-Erling Smørgrav 		my_if = ub_random_max(outnet->rnd, num_if);
1102b7579f77SDag-Erling Smørgrav 		pif = &ifs[my_if];
1103b7579f77SDag-Erling Smørgrav 		my_port = ub_random_max(outnet->rnd, pif->avail_total);
1104b7579f77SDag-Erling Smørgrav 		if(my_port < pif->inuse) {
1105b7579f77SDag-Erling Smørgrav 			/* port already open */
1106b7579f77SDag-Erling Smørgrav 			pend->pc = pif->out[my_port];
1107b7579f77SDag-Erling Smørgrav 			verbose(VERB_ALGO, "using UDP if=%d port=%d",
1108b7579f77SDag-Erling Smørgrav 				my_if, pend->pc->number);
1109b7579f77SDag-Erling Smørgrav 			break;
1110b7579f77SDag-Erling Smørgrav 		}
1111b7579f77SDag-Erling Smørgrav 		/* try to open new port, if fails, loop to try again */
1112b7579f77SDag-Erling Smørgrav 		log_assert(pif->inuse < pif->maxout);
1113b7579f77SDag-Erling Smørgrav 		portno = pif->avail_ports[my_port - pif->inuse];
1114b5663de9SDag-Erling Smørgrav 		fd = udp_sockport(&pif->addr, pif->addrlen, pif->pfxlen,
1115b5663de9SDag-Erling Smørgrav 			portno, &inuse, outnet->rnd);
1116b7579f77SDag-Erling Smørgrav 		if(fd == -1 && !inuse) {
1117b7579f77SDag-Erling Smørgrav 			/* nonrecoverable error making socket */
1118b7579f77SDag-Erling Smørgrav 			return 0;
1119b7579f77SDag-Erling Smørgrav 		}
1120b7579f77SDag-Erling Smørgrav 		if(fd != -1) {
1121b7579f77SDag-Erling Smørgrav 			verbose(VERB_ALGO, "opened UDP if=%d port=%d",
1122b7579f77SDag-Erling Smørgrav 				my_if, portno);
1123b7579f77SDag-Erling Smørgrav 			/* grab fd */
1124b7579f77SDag-Erling Smørgrav 			pend->pc = outnet->unused_fds;
1125b7579f77SDag-Erling Smørgrav 			outnet->unused_fds = pend->pc->next;
1126b7579f77SDag-Erling Smørgrav 
1127b7579f77SDag-Erling Smørgrav 			/* setup portcomm */
1128b7579f77SDag-Erling Smørgrav 			pend->pc->next = NULL;
1129b7579f77SDag-Erling Smørgrav 			pend->pc->number = portno;
1130b7579f77SDag-Erling Smørgrav 			pend->pc->pif = pif;
1131b7579f77SDag-Erling Smørgrav 			pend->pc->index = pif->inuse;
1132b7579f77SDag-Erling Smørgrav 			pend->pc->num_outstanding = 0;
1133b7579f77SDag-Erling Smørgrav 			comm_point_start_listening(pend->pc->cp, fd, -1);
1134b7579f77SDag-Erling Smørgrav 
1135b7579f77SDag-Erling Smørgrav 			/* grab port in interface */
1136b7579f77SDag-Erling Smørgrav 			pif->out[pif->inuse] = pend->pc;
1137b7579f77SDag-Erling Smørgrav 			pif->avail_ports[my_port - pif->inuse] =
1138b7579f77SDag-Erling Smørgrav 				pif->avail_ports[pif->avail_total-pif->inuse-1];
1139b7579f77SDag-Erling Smørgrav 			pif->inuse++;
1140b7579f77SDag-Erling Smørgrav 			break;
1141b7579f77SDag-Erling Smørgrav 		}
1142b7579f77SDag-Erling Smørgrav 		/* failed, already in use */
1143b7579f77SDag-Erling Smørgrav 		verbose(VERB_QUERY, "port %d in use, trying another", portno);
1144b7579f77SDag-Erling Smørgrav 		tries++;
1145b7579f77SDag-Erling Smørgrav 		if(tries == MAX_PORT_RETRY) {
1146b7579f77SDag-Erling Smørgrav 			log_err("failed to find an open port, drop msg");
1147b7579f77SDag-Erling Smørgrav 			return 0;
1148b7579f77SDag-Erling Smørgrav 		}
1149b7579f77SDag-Erling Smørgrav 	}
1150b7579f77SDag-Erling Smørgrav 	log_assert(pend->pc);
1151b7579f77SDag-Erling Smørgrav 	pend->pc->num_outstanding++;
1152b7579f77SDag-Erling Smørgrav 
1153b7579f77SDag-Erling Smørgrav 	return 1;
1154b7579f77SDag-Erling Smørgrav }
1155b7579f77SDag-Erling Smørgrav 
1156b7579f77SDag-Erling Smørgrav static int
1157ff825849SDag-Erling Smørgrav randomize_and_send_udp(struct pending* pend, sldns_buffer* packet, int timeout)
1158b7579f77SDag-Erling Smørgrav {
1159b7579f77SDag-Erling Smørgrav 	struct timeval tv;
1160ff825849SDag-Erling Smørgrav 	struct outside_network* outnet = pend->sq->outnet;
1161b7579f77SDag-Erling Smørgrav 
1162b7579f77SDag-Erling Smørgrav 	/* select id */
1163b7579f77SDag-Erling Smørgrav 	if(!select_id(outnet, pend, packet)) {
1164b7579f77SDag-Erling Smørgrav 		return 0;
1165b7579f77SDag-Erling Smørgrav 	}
1166b7579f77SDag-Erling Smørgrav 
1167b7579f77SDag-Erling Smørgrav 	/* select src_if, port */
1168b7579f77SDag-Erling Smørgrav 	if(addr_is_ip6(&pend->addr, pend->addrlen)) {
1169b7579f77SDag-Erling Smørgrav 		if(!select_ifport(outnet, pend,
1170b7579f77SDag-Erling Smørgrav 			outnet->num_ip6, outnet->ip6_ifs))
1171b7579f77SDag-Erling Smørgrav 			return 0;
1172b7579f77SDag-Erling Smørgrav 	} else {
1173b7579f77SDag-Erling Smørgrav 		if(!select_ifport(outnet, pend,
1174b7579f77SDag-Erling Smørgrav 			outnet->num_ip4, outnet->ip4_ifs))
1175b7579f77SDag-Erling Smørgrav 			return 0;
1176b7579f77SDag-Erling Smørgrav 	}
1177b7579f77SDag-Erling Smørgrav 	log_assert(pend->pc && pend->pc->cp);
1178b7579f77SDag-Erling Smørgrav 
1179b7579f77SDag-Erling Smørgrav 	/* send it over the commlink */
1180b7579f77SDag-Erling Smørgrav 	if(!comm_point_send_udp_msg(pend->pc->cp, packet,
1181b7579f77SDag-Erling Smørgrav 		(struct sockaddr*)&pend->addr, pend->addrlen)) {
1182b7579f77SDag-Erling Smørgrav 		portcomm_loweruse(outnet, pend->pc);
1183b7579f77SDag-Erling Smørgrav 		return 0;
1184b7579f77SDag-Erling Smørgrav 	}
1185b7579f77SDag-Erling Smørgrav 
1186b7579f77SDag-Erling Smørgrav 	/* system calls to set timeout after sending UDP to make roundtrip
1187b7579f77SDag-Erling Smørgrav 	   smaller. */
1188b7579f77SDag-Erling Smørgrav #ifndef S_SPLINT_S
1189b7579f77SDag-Erling Smørgrav 	tv.tv_sec = timeout/1000;
1190b7579f77SDag-Erling Smørgrav 	tv.tv_usec = (timeout%1000)*1000;
1191b7579f77SDag-Erling Smørgrav #endif
1192b7579f77SDag-Erling Smørgrav 	comm_timer_set(pend->timer, &tv);
1193ff825849SDag-Erling Smørgrav 
1194ff825849SDag-Erling Smørgrav #ifdef USE_DNSTAP
1195ff825849SDag-Erling Smørgrav 	if(outnet->dtenv &&
1196ff825849SDag-Erling Smørgrav 	   (outnet->dtenv->log_resolver_query_messages ||
1197ff825849SDag-Erling Smørgrav 	    outnet->dtenv->log_forwarder_query_messages))
1198ff825849SDag-Erling Smørgrav 		dt_msg_send_outside_query(outnet->dtenv, &pend->addr, comm_udp,
1199ff825849SDag-Erling Smørgrav 		pend->sq->zone, pend->sq->zonelen, packet);
1200ff825849SDag-Erling Smørgrav #endif
1201b7579f77SDag-Erling Smørgrav 	return 1;
1202b7579f77SDag-Erling Smørgrav }
1203b7579f77SDag-Erling Smørgrav 
1204b7579f77SDag-Erling Smørgrav struct pending*
1205ff825849SDag-Erling Smørgrav pending_udp_query(struct serviced_query* sq, struct sldns_buffer* packet,
12063005e0a3SDag-Erling Smørgrav 	int timeout, comm_point_callback_type* cb, void* cb_arg)
1207b7579f77SDag-Erling Smørgrav {
1208b7579f77SDag-Erling Smørgrav 	struct pending* pend = (struct pending*)calloc(1, sizeof(*pend));
1209b7579f77SDag-Erling Smørgrav 	if(!pend) return NULL;
1210ff825849SDag-Erling Smørgrav 	pend->outnet = sq->outnet;
1211ff825849SDag-Erling Smørgrav 	pend->sq = sq;
1212ff825849SDag-Erling Smørgrav 	pend->addrlen = sq->addrlen;
1213ff825849SDag-Erling Smørgrav 	memmove(&pend->addr, &sq->addr, sq->addrlen);
1214b7579f77SDag-Erling Smørgrav 	pend->cb = cb;
1215b7579f77SDag-Erling Smørgrav 	pend->cb_arg = cb_arg;
1216b7579f77SDag-Erling Smørgrav 	pend->node.key = pend;
1217ff825849SDag-Erling Smørgrav 	pend->timer = comm_timer_create(sq->outnet->base, pending_udp_timer_cb,
1218b7579f77SDag-Erling Smørgrav 		pend);
1219b7579f77SDag-Erling Smørgrav 	if(!pend->timer) {
1220b7579f77SDag-Erling Smørgrav 		free(pend);
1221b7579f77SDag-Erling Smørgrav 		return NULL;
1222b7579f77SDag-Erling Smørgrav 	}
1223b7579f77SDag-Erling Smørgrav 
1224ff825849SDag-Erling Smørgrav 	if(sq->outnet->unused_fds == NULL) {
1225b7579f77SDag-Erling Smørgrav 		/* no unused fd, cannot create a new port (randomly) */
1226b7579f77SDag-Erling Smørgrav 		verbose(VERB_ALGO, "no fds available, udp query waiting");
1227b7579f77SDag-Erling Smørgrav 		pend->timeout = timeout;
122817d15b25SDag-Erling Smørgrav 		pend->pkt_len = sldns_buffer_limit(packet);
122917d15b25SDag-Erling Smørgrav 		pend->pkt = (uint8_t*)memdup(sldns_buffer_begin(packet),
1230b7579f77SDag-Erling Smørgrav 			pend->pkt_len);
1231b7579f77SDag-Erling Smørgrav 		if(!pend->pkt) {
1232b7579f77SDag-Erling Smørgrav 			comm_timer_delete(pend->timer);
1233b7579f77SDag-Erling Smørgrav 			free(pend);
1234b7579f77SDag-Erling Smørgrav 			return NULL;
1235b7579f77SDag-Erling Smørgrav 		}
1236b7579f77SDag-Erling Smørgrav 		/* put at end of waiting list */
1237ff825849SDag-Erling Smørgrav 		if(sq->outnet->udp_wait_last)
1238ff825849SDag-Erling Smørgrav 			sq->outnet->udp_wait_last->next_waiting = pend;
1239b7579f77SDag-Erling Smørgrav 		else
1240ff825849SDag-Erling Smørgrav 			sq->outnet->udp_wait_first = pend;
1241ff825849SDag-Erling Smørgrav 		sq->outnet->udp_wait_last = pend;
1242b7579f77SDag-Erling Smørgrav 		return pend;
1243b7579f77SDag-Erling Smørgrav 	}
1244ff825849SDag-Erling Smørgrav 	if(!randomize_and_send_udp(pend, packet, timeout)) {
1245ff825849SDag-Erling Smørgrav 		pending_delete(sq->outnet, pend);
1246b7579f77SDag-Erling Smørgrav 		return NULL;
1247b7579f77SDag-Erling Smørgrav 	}
1248b7579f77SDag-Erling Smørgrav 	return pend;
1249b7579f77SDag-Erling Smørgrav }
1250b7579f77SDag-Erling Smørgrav 
1251b7579f77SDag-Erling Smørgrav void
1252b7579f77SDag-Erling Smørgrav outnet_tcptimer(void* arg)
1253b7579f77SDag-Erling Smørgrav {
1254b7579f77SDag-Erling Smørgrav 	struct waiting_tcp* w = (struct waiting_tcp*)arg;
1255b7579f77SDag-Erling Smørgrav 	struct outside_network* outnet = w->outnet;
12563005e0a3SDag-Erling Smørgrav 	comm_point_callback_type* cb;
1257b7579f77SDag-Erling Smørgrav 	void* cb_arg;
1258b7579f77SDag-Erling Smørgrav 	if(w->pkt) {
1259b7579f77SDag-Erling Smørgrav 		/* it is on the waiting list */
1260ff825849SDag-Erling Smørgrav 		waiting_list_remove(outnet, w);
1261b7579f77SDag-Erling Smørgrav 	} else {
1262b7579f77SDag-Erling Smørgrav 		/* it was in use */
1263b7579f77SDag-Erling Smørgrav 		struct pending_tcp* pend=(struct pending_tcp*)w->next_waiting;
1264b7579f77SDag-Erling Smørgrav 		comm_point_close(pend->c);
1265b7579f77SDag-Erling Smørgrav 		pend->query = NULL;
1266b7579f77SDag-Erling Smørgrav 		pend->next_free = outnet->tcp_free;
1267b7579f77SDag-Erling Smørgrav 		outnet->tcp_free = pend;
1268b7579f77SDag-Erling Smørgrav 	}
1269b7579f77SDag-Erling Smørgrav 	cb = w->cb;
1270b7579f77SDag-Erling Smørgrav 	cb_arg = w->cb_arg;
1271b7579f77SDag-Erling Smørgrav 	waiting_tcp_delete(w);
1272b7579f77SDag-Erling Smørgrav 	fptr_ok(fptr_whitelist_pending_tcp(cb));
1273b7579f77SDag-Erling Smørgrav 	(void)(*cb)(NULL, cb_arg, NETEVENT_TIMEOUT, NULL);
1274b7579f77SDag-Erling Smørgrav 	use_free_buffer(outnet);
1275b7579f77SDag-Erling Smørgrav }
1276b7579f77SDag-Erling Smørgrav 
1277b7579f77SDag-Erling Smørgrav struct waiting_tcp*
1278ff825849SDag-Erling Smørgrav pending_tcp_query(struct serviced_query* sq, sldns_buffer* packet,
12793005e0a3SDag-Erling Smørgrav 	int timeout, comm_point_callback_type* callback, void* callback_arg)
1280b7579f77SDag-Erling Smørgrav {
1281ff825849SDag-Erling Smørgrav 	struct pending_tcp* pend = sq->outnet->tcp_free;
1282b7579f77SDag-Erling Smørgrav 	struct waiting_tcp* w;
1283b7579f77SDag-Erling Smørgrav 	struct timeval tv;
1284b7579f77SDag-Erling Smørgrav 	uint16_t id;
1285b7579f77SDag-Erling Smørgrav 	/* if no buffer is free allocate space to store query */
1286b7579f77SDag-Erling Smørgrav 	w = (struct waiting_tcp*)malloc(sizeof(struct waiting_tcp)
128717d15b25SDag-Erling Smørgrav 		+ (pend?0:sldns_buffer_limit(packet)));
1288b7579f77SDag-Erling Smørgrav 	if(!w) {
1289b7579f77SDag-Erling Smørgrav 		return NULL;
1290b7579f77SDag-Erling Smørgrav 	}
1291ff825849SDag-Erling Smørgrav 	if(!(w->timer = comm_timer_create(sq->outnet->base, outnet_tcptimer, w))) {
1292b7579f77SDag-Erling Smørgrav 		free(w);
1293b7579f77SDag-Erling Smørgrav 		return NULL;
1294b7579f77SDag-Erling Smørgrav 	}
1295b7579f77SDag-Erling Smørgrav 	w->pkt = NULL;
1296b7579f77SDag-Erling Smørgrav 	w->pkt_len = 0;
1297ff825849SDag-Erling Smørgrav 	id = ((unsigned)ub_random(sq->outnet->rnd)>>8) & 0xffff;
129817d15b25SDag-Erling Smørgrav 	LDNS_ID_SET(sldns_buffer_begin(packet), id);
1299ff825849SDag-Erling Smørgrav 	memcpy(&w->addr, &sq->addr, sq->addrlen);
1300ff825849SDag-Erling Smørgrav 	w->addrlen = sq->addrlen;
1301ff825849SDag-Erling Smørgrav 	w->outnet = sq->outnet;
1302b7579f77SDag-Erling Smørgrav 	w->cb = callback;
1303b7579f77SDag-Erling Smørgrav 	w->cb_arg = callback_arg;
1304ff825849SDag-Erling Smørgrav 	w->ssl_upstream = sq->ssl_upstream;
13050fb34990SDag-Erling Smørgrav 	w->tls_auth_name = sq->tls_auth_name;
1306b7579f77SDag-Erling Smørgrav #ifndef S_SPLINT_S
13073bd4df0aSDag-Erling Smørgrav 	tv.tv_sec = timeout/1000;
13083bd4df0aSDag-Erling Smørgrav 	tv.tv_usec = (timeout%1000)*1000;
1309b7579f77SDag-Erling Smørgrav #endif
1310b7579f77SDag-Erling Smørgrav 	comm_timer_set(w->timer, &tv);
1311b7579f77SDag-Erling Smørgrav 	if(pend) {
1312b7579f77SDag-Erling Smørgrav 		/* we have a buffer available right now */
131317d15b25SDag-Erling Smørgrav 		if(!outnet_tcp_take_into_use(w, sldns_buffer_begin(packet),
131417d15b25SDag-Erling Smørgrav 			sldns_buffer_limit(packet))) {
1315b7579f77SDag-Erling Smørgrav 			waiting_tcp_delete(w);
1316b7579f77SDag-Erling Smørgrav 			return NULL;
1317b7579f77SDag-Erling Smørgrav 		}
1318ff825849SDag-Erling Smørgrav #ifdef USE_DNSTAP
1319ff825849SDag-Erling Smørgrav 		if(sq->outnet->dtenv &&
1320ff825849SDag-Erling Smørgrav 		   (sq->outnet->dtenv->log_resolver_query_messages ||
1321ff825849SDag-Erling Smørgrav 		    sq->outnet->dtenv->log_forwarder_query_messages))
1322ff825849SDag-Erling Smørgrav 		dt_msg_send_outside_query(sq->outnet->dtenv, &sq->addr,
1323ff825849SDag-Erling Smørgrav 		comm_tcp, sq->zone, sq->zonelen, packet);
1324ff825849SDag-Erling Smørgrav #endif
1325b7579f77SDag-Erling Smørgrav 	} else {
1326b7579f77SDag-Erling Smørgrav 		/* queue up */
1327b7579f77SDag-Erling Smørgrav 		w->pkt = (uint8_t*)w + sizeof(struct waiting_tcp);
132817d15b25SDag-Erling Smørgrav 		w->pkt_len = sldns_buffer_limit(packet);
132917d15b25SDag-Erling Smørgrav 		memmove(w->pkt, sldns_buffer_begin(packet), w->pkt_len);
1330b7579f77SDag-Erling Smørgrav 		w->next_waiting = NULL;
1331ff825849SDag-Erling Smørgrav 		if(sq->outnet->tcp_wait_last)
1332ff825849SDag-Erling Smørgrav 			sq->outnet->tcp_wait_last->next_waiting = w;
1333ff825849SDag-Erling Smørgrav 		else	sq->outnet->tcp_wait_first = w;
1334ff825849SDag-Erling Smørgrav 		sq->outnet->tcp_wait_last = w;
1335b7579f77SDag-Erling Smørgrav 	}
1336b7579f77SDag-Erling Smørgrav 	return w;
1337b7579f77SDag-Erling Smørgrav }
1338b7579f77SDag-Erling Smørgrav 
1339b7579f77SDag-Erling Smørgrav /** create query for serviced queries */
1340b7579f77SDag-Erling Smørgrav static void
134117d15b25SDag-Erling Smørgrav serviced_gen_query(sldns_buffer* buff, uint8_t* qname, size_t qnamelen,
1342b7579f77SDag-Erling Smørgrav 	uint16_t qtype, uint16_t qclass, uint16_t flags)
1343b7579f77SDag-Erling Smørgrav {
134417d15b25SDag-Erling Smørgrav 	sldns_buffer_clear(buff);
1345b7579f77SDag-Erling Smørgrav 	/* skip id */
134617d15b25SDag-Erling Smørgrav 	sldns_buffer_write_u16(buff, flags);
134717d15b25SDag-Erling Smørgrav 	sldns_buffer_write_u16(buff, 1); /* qdcount */
134817d15b25SDag-Erling Smørgrav 	sldns_buffer_write_u16(buff, 0); /* ancount */
134917d15b25SDag-Erling Smørgrav 	sldns_buffer_write_u16(buff, 0); /* nscount */
135017d15b25SDag-Erling Smørgrav 	sldns_buffer_write_u16(buff, 0); /* arcount */
135117d15b25SDag-Erling Smørgrav 	sldns_buffer_write(buff, qname, qnamelen);
135217d15b25SDag-Erling Smørgrav 	sldns_buffer_write_u16(buff, qtype);
135317d15b25SDag-Erling Smørgrav 	sldns_buffer_write_u16(buff, qclass);
135417d15b25SDag-Erling Smørgrav 	sldns_buffer_flip(buff);
1355b7579f77SDag-Erling Smørgrav }
1356b7579f77SDag-Erling Smørgrav 
1357b7579f77SDag-Erling Smørgrav /** lookup serviced query in serviced query rbtree */
1358b7579f77SDag-Erling Smørgrav static struct serviced_query*
135917d15b25SDag-Erling Smørgrav lookup_serviced(struct outside_network* outnet, sldns_buffer* buff, int dnssec,
1360e2d15004SDag-Erling Smørgrav 	struct sockaddr_storage* addr, socklen_t addrlen,
1361e2d15004SDag-Erling Smørgrav 	struct edns_option* opt_list)
1362b7579f77SDag-Erling Smørgrav {
1363b7579f77SDag-Erling Smørgrav 	struct serviced_query key;
1364b7579f77SDag-Erling Smørgrav 	key.node.key = &key;
136517d15b25SDag-Erling Smørgrav 	key.qbuf = sldns_buffer_begin(buff);
136617d15b25SDag-Erling Smørgrav 	key.qbuflen = sldns_buffer_limit(buff);
1367b7579f77SDag-Erling Smørgrav 	key.dnssec = dnssec;
1368b7579f77SDag-Erling Smørgrav 	memcpy(&key.addr, addr, addrlen);
1369b7579f77SDag-Erling Smørgrav 	key.addrlen = addrlen;
1370b7579f77SDag-Erling Smørgrav 	key.outnet = outnet;
1371e2d15004SDag-Erling Smørgrav 	key.opt_list = opt_list;
1372b7579f77SDag-Erling Smørgrav 	return (struct serviced_query*)rbtree_search(outnet->serviced, &key);
1373b7579f77SDag-Erling Smørgrav }
1374b7579f77SDag-Erling Smørgrav 
1375b7579f77SDag-Erling Smørgrav /** Create new serviced entry */
1376b7579f77SDag-Erling Smørgrav static struct serviced_query*
137717d15b25SDag-Erling Smørgrav serviced_create(struct outside_network* outnet, sldns_buffer* buff, int dnssec,
1378ff825849SDag-Erling Smørgrav 	int want_dnssec, int nocaps, int tcp_upstream, int ssl_upstream,
13790fb34990SDag-Erling Smørgrav 	char* tls_auth_name, struct sockaddr_storage* addr, socklen_t addrlen,
13800fb34990SDag-Erling Smørgrav 	uint8_t* zone, size_t zonelen, int qtype, struct edns_option* opt_list)
1381b7579f77SDag-Erling Smørgrav {
1382b7579f77SDag-Erling Smørgrav 	struct serviced_query* sq = (struct serviced_query*)malloc(sizeof(*sq));
1383b7579f77SDag-Erling Smørgrav #ifdef UNBOUND_DEBUG
13843005e0a3SDag-Erling Smørgrav 	rbnode_type* ins;
1385b7579f77SDag-Erling Smørgrav #endif
1386b7579f77SDag-Erling Smørgrav 	if(!sq)
1387b7579f77SDag-Erling Smørgrav 		return NULL;
1388b7579f77SDag-Erling Smørgrav 	sq->node.key = sq;
138917d15b25SDag-Erling Smørgrav 	sq->qbuf = memdup(sldns_buffer_begin(buff), sldns_buffer_limit(buff));
1390b7579f77SDag-Erling Smørgrav 	if(!sq->qbuf) {
1391b7579f77SDag-Erling Smørgrav 		free(sq);
1392b7579f77SDag-Erling Smørgrav 		return NULL;
1393b7579f77SDag-Erling Smørgrav 	}
139417d15b25SDag-Erling Smørgrav 	sq->qbuflen = sldns_buffer_limit(buff);
1395b7579f77SDag-Erling Smørgrav 	sq->zone = memdup(zone, zonelen);
1396b7579f77SDag-Erling Smørgrav 	if(!sq->zone) {
1397b7579f77SDag-Erling Smørgrav 		free(sq->qbuf);
1398b7579f77SDag-Erling Smørgrav 		free(sq);
1399b7579f77SDag-Erling Smørgrav 		return NULL;
1400b7579f77SDag-Erling Smørgrav 	}
1401b7579f77SDag-Erling Smørgrav 	sq->zonelen = zonelen;
1402b7579f77SDag-Erling Smørgrav 	sq->qtype = qtype;
1403b7579f77SDag-Erling Smørgrav 	sq->dnssec = dnssec;
1404b7579f77SDag-Erling Smørgrav 	sq->want_dnssec = want_dnssec;
1405ff825849SDag-Erling Smørgrav 	sq->nocaps = nocaps;
1406b7579f77SDag-Erling Smørgrav 	sq->tcp_upstream = tcp_upstream;
1407b7579f77SDag-Erling Smørgrav 	sq->ssl_upstream = ssl_upstream;
14080fb34990SDag-Erling Smørgrav 	if(tls_auth_name) {
14090fb34990SDag-Erling Smørgrav 		sq->tls_auth_name = strdup(tls_auth_name);
14100fb34990SDag-Erling Smørgrav 		if(!sq->tls_auth_name) {
14110fb34990SDag-Erling Smørgrav 			free(sq->zone);
14120fb34990SDag-Erling Smørgrav 			free(sq->qbuf);
14130fb34990SDag-Erling Smørgrav 			free(sq);
14140fb34990SDag-Erling Smørgrav 			return NULL;
14150fb34990SDag-Erling Smørgrav 		}
14160fb34990SDag-Erling Smørgrav 	} else {
14170fb34990SDag-Erling Smørgrav 		sq->tls_auth_name = NULL;
14180fb34990SDag-Erling Smørgrav 	}
1419b7579f77SDag-Erling Smørgrav 	memcpy(&sq->addr, addr, addrlen);
1420b7579f77SDag-Erling Smørgrav 	sq->addrlen = addrlen;
1421e2d15004SDag-Erling Smørgrav 	sq->opt_list = NULL;
1422e2d15004SDag-Erling Smørgrav 	if(opt_list) {
1423e2d15004SDag-Erling Smørgrav 		sq->opt_list = edns_opt_copy_alloc(opt_list);
1424e2d15004SDag-Erling Smørgrav 		if(!sq->opt_list) {
14250fb34990SDag-Erling Smørgrav 			free(sq->tls_auth_name);
1426e2d15004SDag-Erling Smørgrav 			free(sq->zone);
1427e2d15004SDag-Erling Smørgrav 			free(sq->qbuf);
1428e2d15004SDag-Erling Smørgrav 			free(sq);
1429e2d15004SDag-Erling Smørgrav 			return NULL;
1430e2d15004SDag-Erling Smørgrav 		}
1431e2d15004SDag-Erling Smørgrav 	}
1432b7579f77SDag-Erling Smørgrav 	sq->outnet = outnet;
1433b7579f77SDag-Erling Smørgrav 	sq->cblist = NULL;
1434b7579f77SDag-Erling Smørgrav 	sq->pending = NULL;
1435b7579f77SDag-Erling Smørgrav 	sq->status = serviced_initial;
1436b7579f77SDag-Erling Smørgrav 	sq->retry = 0;
1437b7579f77SDag-Erling Smørgrav 	sq->to_be_deleted = 0;
1438b7579f77SDag-Erling Smørgrav #ifdef UNBOUND_DEBUG
1439b7579f77SDag-Erling Smørgrav 	ins =
144017d15b25SDag-Erling Smørgrav #else
144117d15b25SDag-Erling Smørgrav 	(void)
1442b7579f77SDag-Erling Smørgrav #endif
1443b7579f77SDag-Erling Smørgrav 	rbtree_insert(outnet->serviced, &sq->node);
1444b7579f77SDag-Erling Smørgrav 	log_assert(ins != NULL); /* must not be already present */
1445b7579f77SDag-Erling Smørgrav 	return sq;
1446b7579f77SDag-Erling Smørgrav }
1447b7579f77SDag-Erling Smørgrav 
1448b7579f77SDag-Erling Smørgrav /** remove waiting tcp from the outnet waiting list */
1449b7579f77SDag-Erling Smørgrav static void
1450b7579f77SDag-Erling Smørgrav waiting_list_remove(struct outside_network* outnet, struct waiting_tcp* w)
1451b7579f77SDag-Erling Smørgrav {
1452b7579f77SDag-Erling Smørgrav 	struct waiting_tcp* p = outnet->tcp_wait_first, *prev = NULL;
1453b7579f77SDag-Erling Smørgrav 	while(p) {
1454b7579f77SDag-Erling Smørgrav 		if(p == w) {
1455b7579f77SDag-Erling Smørgrav 			/* remove w */
1456b7579f77SDag-Erling Smørgrav 			if(prev)
1457b7579f77SDag-Erling Smørgrav 				prev->next_waiting = w->next_waiting;
1458b7579f77SDag-Erling Smørgrav 			else	outnet->tcp_wait_first = w->next_waiting;
1459b7579f77SDag-Erling Smørgrav 			if(outnet->tcp_wait_last == w)
1460b7579f77SDag-Erling Smørgrav 				outnet->tcp_wait_last = prev;
1461b7579f77SDag-Erling Smørgrav 			return;
1462b7579f77SDag-Erling Smørgrav 		}
1463b7579f77SDag-Erling Smørgrav 		prev = p;
1464b7579f77SDag-Erling Smørgrav 		p = p->next_waiting;
1465b7579f77SDag-Erling Smørgrav 	}
1466b7579f77SDag-Erling Smørgrav }
1467b7579f77SDag-Erling Smørgrav 
1468b7579f77SDag-Erling Smørgrav /** cleanup serviced query entry */
1469b7579f77SDag-Erling Smørgrav static void
1470b7579f77SDag-Erling Smørgrav serviced_delete(struct serviced_query* sq)
1471b7579f77SDag-Erling Smørgrav {
1472b7579f77SDag-Erling Smørgrav 	if(sq->pending) {
1473b7579f77SDag-Erling Smørgrav 		/* clear up the pending query */
1474b7579f77SDag-Erling Smørgrav 		if(sq->status == serviced_query_UDP_EDNS ||
1475b7579f77SDag-Erling Smørgrav 			sq->status == serviced_query_UDP ||
1476b7579f77SDag-Erling Smørgrav 			sq->status == serviced_query_PROBE_EDNS ||
1477b7579f77SDag-Erling Smørgrav 			sq->status == serviced_query_UDP_EDNS_FRAG ||
1478b7579f77SDag-Erling Smørgrav 			sq->status == serviced_query_UDP_EDNS_fallback) {
1479b7579f77SDag-Erling Smørgrav 			struct pending* p = (struct pending*)sq->pending;
1480b7579f77SDag-Erling Smørgrav 			if(p->pc)
1481b7579f77SDag-Erling Smørgrav 				portcomm_loweruse(sq->outnet, p->pc);
1482b7579f77SDag-Erling Smørgrav 			pending_delete(sq->outnet, p);
1483b7579f77SDag-Erling Smørgrav 			/* this call can cause reentrant calls back into the
1484b7579f77SDag-Erling Smørgrav 			 * mesh */
1485b7579f77SDag-Erling Smørgrav 			outnet_send_wait_udp(sq->outnet);
1486b7579f77SDag-Erling Smørgrav 		} else {
1487b7579f77SDag-Erling Smørgrav 			struct waiting_tcp* p = (struct waiting_tcp*)
1488b7579f77SDag-Erling Smørgrav 				sq->pending;
1489b7579f77SDag-Erling Smørgrav 			if(p->pkt == NULL) {
14908a384985SDag-Erling Smørgrav 				decommission_pending_tcp(sq->outnet,
1491b7579f77SDag-Erling Smørgrav 					(struct pending_tcp*)p->next_waiting);
1492b7579f77SDag-Erling Smørgrav 			} else {
1493b7579f77SDag-Erling Smørgrav 				waiting_list_remove(sq->outnet, p);
1494b7579f77SDag-Erling Smørgrav 				waiting_tcp_delete(p);
1495b7579f77SDag-Erling Smørgrav 			}
1496b7579f77SDag-Erling Smørgrav 		}
1497b7579f77SDag-Erling Smørgrav 	}
1498b7579f77SDag-Erling Smørgrav 	/* does not delete from tree, caller has to do that */
1499b7579f77SDag-Erling Smørgrav 	serviced_node_del(&sq->node, NULL);
1500b7579f77SDag-Erling Smørgrav }
1501b7579f77SDag-Erling Smørgrav 
1502b7579f77SDag-Erling Smørgrav /** perturb a dname capitalization randomly */
1503b7579f77SDag-Erling Smørgrav static void
1504b7579f77SDag-Erling Smørgrav serviced_perturb_qname(struct ub_randstate* rnd, uint8_t* qbuf, size_t len)
1505b7579f77SDag-Erling Smørgrav {
1506b7579f77SDag-Erling Smørgrav 	uint8_t lablen;
1507b7579f77SDag-Erling Smørgrav 	uint8_t* d = qbuf + 10;
1508b7579f77SDag-Erling Smørgrav 	long int random = 0;
1509b7579f77SDag-Erling Smørgrav 	int bits = 0;
1510b7579f77SDag-Erling Smørgrav 	log_assert(len >= 10 + 5 /* offset qname, root, qtype, qclass */);
1511b5663de9SDag-Erling Smørgrav 	(void)len;
1512b7579f77SDag-Erling Smørgrav 	lablen = *d++;
1513b7579f77SDag-Erling Smørgrav 	while(lablen) {
1514b7579f77SDag-Erling Smørgrav 		while(lablen--) {
1515b7579f77SDag-Erling Smørgrav 			/* only perturb A-Z, a-z */
1516ff825849SDag-Erling Smørgrav 			if(isalpha((unsigned char)*d)) {
1517b7579f77SDag-Erling Smørgrav 				/* get a random bit */
1518b7579f77SDag-Erling Smørgrav 				if(bits == 0) {
1519b7579f77SDag-Erling Smørgrav 					random = ub_random(rnd);
1520b7579f77SDag-Erling Smørgrav 					bits = 30;
1521b7579f77SDag-Erling Smørgrav 				}
1522b7579f77SDag-Erling Smørgrav 				if(random & 0x1) {
1523ff825849SDag-Erling Smørgrav 					*d = (uint8_t)toupper((unsigned char)*d);
1524b7579f77SDag-Erling Smørgrav 				} else {
1525ff825849SDag-Erling Smørgrav 					*d = (uint8_t)tolower((unsigned char)*d);
1526b7579f77SDag-Erling Smørgrav 				}
1527b7579f77SDag-Erling Smørgrav 				random >>= 1;
1528b7579f77SDag-Erling Smørgrav 				bits--;
1529b7579f77SDag-Erling Smørgrav 			}
1530b7579f77SDag-Erling Smørgrav 			d++;
1531b7579f77SDag-Erling Smørgrav 		}
1532b7579f77SDag-Erling Smørgrav 		lablen = *d++;
1533b7579f77SDag-Erling Smørgrav 	}
1534b7579f77SDag-Erling Smørgrav 	if(verbosity >= VERB_ALGO) {
1535b7579f77SDag-Erling Smørgrav 		char buf[LDNS_MAX_DOMAINLEN+1];
1536b7579f77SDag-Erling Smørgrav 		dname_str(qbuf+10, buf);
1537b7579f77SDag-Erling Smørgrav 		verbose(VERB_ALGO, "qname perturbed to %s", buf);
1538b7579f77SDag-Erling Smørgrav 	}
1539b7579f77SDag-Erling Smørgrav }
1540b7579f77SDag-Erling Smørgrav 
1541b7579f77SDag-Erling Smørgrav /** put serviced query into a buffer */
1542b7579f77SDag-Erling Smørgrav static void
154317d15b25SDag-Erling Smørgrav serviced_encode(struct serviced_query* sq, sldns_buffer* buff, int with_edns)
1544b7579f77SDag-Erling Smørgrav {
1545b7579f77SDag-Erling Smørgrav 	/* if we are using 0x20 bits for ID randomness, perturb them */
1546ff825849SDag-Erling Smørgrav 	if(sq->outnet->use_caps_for_id && !sq->nocaps) {
1547b7579f77SDag-Erling Smørgrav 		serviced_perturb_qname(sq->outnet->rnd, sq->qbuf, sq->qbuflen);
1548b7579f77SDag-Erling Smørgrav 	}
1549b7579f77SDag-Erling Smørgrav 	/* generate query */
155017d15b25SDag-Erling Smørgrav 	sldns_buffer_clear(buff);
155117d15b25SDag-Erling Smørgrav 	sldns_buffer_write_u16(buff, 0); /* id placeholder */
155217d15b25SDag-Erling Smørgrav 	sldns_buffer_write(buff, sq->qbuf, sq->qbuflen);
155317d15b25SDag-Erling Smørgrav 	sldns_buffer_flip(buff);
1554b7579f77SDag-Erling Smørgrav 	if(with_edns) {
1555b7579f77SDag-Erling Smørgrav 		/* add edns section */
1556b7579f77SDag-Erling Smørgrav 		struct edns_data edns;
1557b7579f77SDag-Erling Smørgrav 		edns.edns_present = 1;
1558b7579f77SDag-Erling Smørgrav 		edns.ext_rcode = 0;
1559b7579f77SDag-Erling Smørgrav 		edns.edns_version = EDNS_ADVERTISED_VERSION;
1560e2d15004SDag-Erling Smørgrav 		edns.opt_list = sq->opt_list;
1561b7579f77SDag-Erling Smørgrav 		if(sq->status == serviced_query_UDP_EDNS_FRAG) {
1562b7579f77SDag-Erling Smørgrav 			if(addr_is_ip6(&sq->addr, sq->addrlen)) {
1563b7579f77SDag-Erling Smørgrav 				if(EDNS_FRAG_SIZE_IP6 < EDNS_ADVERTISED_SIZE)
1564b7579f77SDag-Erling Smørgrav 					edns.udp_size = EDNS_FRAG_SIZE_IP6;
1565b7579f77SDag-Erling Smørgrav 				else	edns.udp_size = EDNS_ADVERTISED_SIZE;
1566b7579f77SDag-Erling Smørgrav 			} else {
1567b7579f77SDag-Erling Smørgrav 				if(EDNS_FRAG_SIZE_IP4 < EDNS_ADVERTISED_SIZE)
1568b7579f77SDag-Erling Smørgrav 					edns.udp_size = EDNS_FRAG_SIZE_IP4;
1569b7579f77SDag-Erling Smørgrav 				else	edns.udp_size = EDNS_ADVERTISED_SIZE;
1570b7579f77SDag-Erling Smørgrav 			}
1571b7579f77SDag-Erling Smørgrav 		} else {
1572b7579f77SDag-Erling Smørgrav 			edns.udp_size = EDNS_ADVERTISED_SIZE;
1573b7579f77SDag-Erling Smørgrav 		}
1574b7579f77SDag-Erling Smørgrav 		edns.bits = 0;
1575b7579f77SDag-Erling Smørgrav 		if(sq->dnssec & EDNS_DO)
1576b7579f77SDag-Erling Smørgrav 			edns.bits = EDNS_DO;
1577b7579f77SDag-Erling Smørgrav 		if(sq->dnssec & BIT_CD)
157817d15b25SDag-Erling Smørgrav 			LDNS_CD_SET(sldns_buffer_begin(buff));
1579b7579f77SDag-Erling Smørgrav 		attach_edns_record(buff, &edns);
1580b7579f77SDag-Erling Smørgrav 	}
1581b7579f77SDag-Erling Smørgrav }
1582b7579f77SDag-Erling Smørgrav 
1583b7579f77SDag-Erling Smørgrav /**
1584b7579f77SDag-Erling Smørgrav  * Perform serviced query UDP sending operation.
1585b7579f77SDag-Erling Smørgrav  * Sends UDP with EDNS, unless infra host marked non EDNS.
1586b7579f77SDag-Erling Smørgrav  * @param sq: query to send.
1587b7579f77SDag-Erling Smørgrav  * @param buff: buffer scratch space.
1588b7579f77SDag-Erling Smørgrav  * @return 0 on error.
1589b7579f77SDag-Erling Smørgrav  */
1590b7579f77SDag-Erling Smørgrav static int
159117d15b25SDag-Erling Smørgrav serviced_udp_send(struct serviced_query* sq, sldns_buffer* buff)
1592b7579f77SDag-Erling Smørgrav {
1593b7579f77SDag-Erling Smørgrav 	int rtt, vs;
1594b7579f77SDag-Erling Smørgrav 	uint8_t edns_lame_known;
159517d15b25SDag-Erling Smørgrav 	time_t now = *sq->outnet->now_secs;
1596b7579f77SDag-Erling Smørgrav 
1597b7579f77SDag-Erling Smørgrav 	if(!infra_host(sq->outnet->infra, &sq->addr, sq->addrlen, sq->zone,
1598b7579f77SDag-Erling Smørgrav 		sq->zonelen, now, &vs, &edns_lame_known, &rtt))
1599b7579f77SDag-Erling Smørgrav 		return 0;
1600b7579f77SDag-Erling Smørgrav 	sq->last_rtt = rtt;
1601b7579f77SDag-Erling Smørgrav 	verbose(VERB_ALGO, "EDNS lookup known=%d vs=%d", edns_lame_known, vs);
1602b7579f77SDag-Erling Smørgrav 	if(sq->status == serviced_initial) {
1603b7579f77SDag-Erling Smørgrav 		if(edns_lame_known == 0 && rtt > 5000 && rtt < 10001) {
1604b7579f77SDag-Erling Smørgrav 			/* perform EDNS lame probe - check if server is
1605b7579f77SDag-Erling Smørgrav 			 * EDNS lame (EDNS queries to it are dropped) */
1606b7579f77SDag-Erling Smørgrav 			verbose(VERB_ALGO, "serviced query: send probe to see "
1607b7579f77SDag-Erling Smørgrav 				" if use of EDNS causes timeouts");
1608b7579f77SDag-Erling Smørgrav 			/* even 700 msec may be too small */
1609b7579f77SDag-Erling Smørgrav 			rtt = 1000;
1610b7579f77SDag-Erling Smørgrav 			sq->status = serviced_query_PROBE_EDNS;
1611b7579f77SDag-Erling Smørgrav 		} else if(vs != -1) {
1612b7579f77SDag-Erling Smørgrav 			sq->status = serviced_query_UDP_EDNS;
1613b7579f77SDag-Erling Smørgrav 		} else {
1614b7579f77SDag-Erling Smørgrav 			sq->status = serviced_query_UDP;
1615b7579f77SDag-Erling Smørgrav 		}
1616b7579f77SDag-Erling Smørgrav 	}
1617b7579f77SDag-Erling Smørgrav 	serviced_encode(sq, buff, (sq->status == serviced_query_UDP_EDNS) ||
1618b7579f77SDag-Erling Smørgrav 		(sq->status == serviced_query_UDP_EDNS_FRAG));
1619b7579f77SDag-Erling Smørgrav 	sq->last_sent_time = *sq->outnet->now_tv;
1620b7579f77SDag-Erling Smørgrav 	sq->edns_lame_known = (int)edns_lame_known;
1621b7579f77SDag-Erling Smørgrav 	verbose(VERB_ALGO, "serviced query UDP timeout=%d msec", rtt);
1622ff825849SDag-Erling Smørgrav 	sq->pending = pending_udp_query(sq, buff, rtt,
1623ff825849SDag-Erling Smørgrav 		serviced_udp_callback, sq);
1624b7579f77SDag-Erling Smørgrav 	if(!sq->pending)
1625b7579f77SDag-Erling Smørgrav 		return 0;
1626b7579f77SDag-Erling Smørgrav 	return 1;
1627b7579f77SDag-Erling Smørgrav }
1628b7579f77SDag-Erling Smørgrav 
1629b7579f77SDag-Erling Smørgrav /** check that perturbed qname is identical */
1630b7579f77SDag-Erling Smørgrav static int
163117d15b25SDag-Erling Smørgrav serviced_check_qname(sldns_buffer* pkt, uint8_t* qbuf, size_t qbuflen)
1632b7579f77SDag-Erling Smørgrav {
1633c7f4d7adSDag-Erling Smørgrav 	uint8_t* d1 = sldns_buffer_begin(pkt)+12;
1634b7579f77SDag-Erling Smørgrav 	uint8_t* d2 = qbuf+10;
1635b7579f77SDag-Erling Smørgrav 	uint8_t len1, len2;
1636b7579f77SDag-Erling Smørgrav 	int count = 0;
1637c7f4d7adSDag-Erling Smørgrav 	if(sldns_buffer_limit(pkt) < 12+1+4) /* packet too small for qname */
1638c7f4d7adSDag-Erling Smørgrav 		return 0;
1639b7579f77SDag-Erling Smørgrav 	log_assert(qbuflen >= 15 /* 10 header, root, type, class */);
1640b7579f77SDag-Erling Smørgrav 	len1 = *d1++;
1641b7579f77SDag-Erling Smørgrav 	len2 = *d2++;
1642b7579f77SDag-Erling Smørgrav 	while(len1 != 0 || len2 != 0) {
1643b7579f77SDag-Erling Smørgrav 		if(LABEL_IS_PTR(len1)) {
1644c7f4d7adSDag-Erling Smørgrav 			/* check if we can read *d1 with compression ptr rest */
1645c7f4d7adSDag-Erling Smørgrav 			if(d1 >= sldns_buffer_at(pkt, sldns_buffer_limit(pkt)))
1646c7f4d7adSDag-Erling Smørgrav 				return 0;
164792bb4ebdSDag-Erling Smørgrav 			d1 = sldns_buffer_begin(pkt)+PTR_OFFSET(len1, *d1);
1648c7f4d7adSDag-Erling Smørgrav 			/* check if we can read the destination *d1 */
164917d15b25SDag-Erling Smørgrav 			if(d1 >= sldns_buffer_at(pkt, sldns_buffer_limit(pkt)))
1650b7579f77SDag-Erling Smørgrav 				return 0;
1651b7579f77SDag-Erling Smørgrav 			len1 = *d1++;
1652b7579f77SDag-Erling Smørgrav 			if(count++ > MAX_COMPRESS_PTRS)
1653b7579f77SDag-Erling Smørgrav 				return 0;
1654b7579f77SDag-Erling Smørgrav 			continue;
1655b7579f77SDag-Erling Smørgrav 		}
1656b7579f77SDag-Erling Smørgrav 		if(d2 > qbuf+qbuflen)
1657b7579f77SDag-Erling Smørgrav 			return 0;
1658b7579f77SDag-Erling Smørgrav 		if(len1 != len2)
1659b7579f77SDag-Erling Smørgrav 			return 0;
1660b7579f77SDag-Erling Smørgrav 		if(len1 > LDNS_MAX_LABELLEN)
1661b7579f77SDag-Erling Smørgrav 			return 0;
1662c7f4d7adSDag-Erling Smørgrav 		/* check len1 + 1(next length) are okay to read */
1663c7f4d7adSDag-Erling Smørgrav 		if(d1+len1 >= sldns_buffer_at(pkt, sldns_buffer_limit(pkt)))
1664c7f4d7adSDag-Erling Smørgrav 			return 0;
1665b7579f77SDag-Erling Smørgrav 		log_assert(len1 <= LDNS_MAX_LABELLEN);
1666b7579f77SDag-Erling Smørgrav 		log_assert(len2 <= LDNS_MAX_LABELLEN);
1667b7579f77SDag-Erling Smørgrav 		log_assert(len1 == len2 && len1 != 0);
1668b7579f77SDag-Erling Smørgrav 		/* compare the labels - bitwise identical */
1669b7579f77SDag-Erling Smørgrav 		if(memcmp(d1, d2, len1) != 0)
1670b7579f77SDag-Erling Smørgrav 			return 0;
1671b7579f77SDag-Erling Smørgrav 		d1 += len1;
1672b7579f77SDag-Erling Smørgrav 		d2 += len2;
1673b7579f77SDag-Erling Smørgrav 		len1 = *d1++;
1674b7579f77SDag-Erling Smørgrav 		len2 = *d2++;
1675b7579f77SDag-Erling Smørgrav 	}
1676b7579f77SDag-Erling Smørgrav 	return 1;
1677b7579f77SDag-Erling Smørgrav }
1678b7579f77SDag-Erling Smørgrav 
1679b7579f77SDag-Erling Smørgrav /** call the callbacks for a serviced query */
1680b7579f77SDag-Erling Smørgrav static void
1681b7579f77SDag-Erling Smørgrav serviced_callbacks(struct serviced_query* sq, int error, struct comm_point* c,
1682b7579f77SDag-Erling Smørgrav 	struct comm_reply* rep)
1683b7579f77SDag-Erling Smørgrav {
16848ed2b524SDag-Erling Smørgrav 	struct service_callback* p;
1685b7579f77SDag-Erling Smørgrav 	int dobackup = (sq->cblist && sq->cblist->next); /* >1 cb*/
1686b7579f77SDag-Erling Smørgrav 	uint8_t *backup_p = NULL;
1687b7579f77SDag-Erling Smørgrav 	size_t backlen = 0;
1688b7579f77SDag-Erling Smørgrav #ifdef UNBOUND_DEBUG
16893005e0a3SDag-Erling Smørgrav 	rbnode_type* rem =
169017d15b25SDag-Erling Smørgrav #else
169117d15b25SDag-Erling Smørgrav 	(void)
1692b7579f77SDag-Erling Smørgrav #endif
1693b7579f77SDag-Erling Smørgrav 	/* remove from tree, and schedule for deletion, so that callbacks
1694b7579f77SDag-Erling Smørgrav 	 * can safely deregister themselves and even create new serviced
1695b7579f77SDag-Erling Smørgrav 	 * queries that are identical to this one. */
1696b7579f77SDag-Erling Smørgrav 	rbtree_delete(sq->outnet->serviced, sq);
1697b7579f77SDag-Erling Smørgrav 	log_assert(rem); /* should have been present */
1698b7579f77SDag-Erling Smørgrav 	sq->to_be_deleted = 1;
1699b7579f77SDag-Erling Smørgrav 	verbose(VERB_ALGO, "svcd callbacks start");
170009a3aaf3SDag-Erling Smørgrav 	if(sq->outnet->use_caps_for_id && error == NETEVENT_NOERROR && c &&
1701e2d15004SDag-Erling Smørgrav 		!sq->nocaps && sq->qtype != LDNS_RR_TYPE_PTR) {
1702e2d15004SDag-Erling Smørgrav 		/* for type PTR do not check perturbed name in answer,
1703e2d15004SDag-Erling Smørgrav 		 * compatibility with cisco dns guard boxes that mess up
1704e2d15004SDag-Erling Smørgrav 		 * reverse queries 0x20 contents */
1705b7579f77SDag-Erling Smørgrav 		/* noerror and nxdomain must have a qname in reply */
170617d15b25SDag-Erling Smørgrav 		if(sldns_buffer_read_u16_at(c->buffer, 4) == 0 &&
170717d15b25SDag-Erling Smørgrav 			(LDNS_RCODE_WIRE(sldns_buffer_begin(c->buffer))
1708b7579f77SDag-Erling Smørgrav 				== LDNS_RCODE_NOERROR ||
170917d15b25SDag-Erling Smørgrav 			 LDNS_RCODE_WIRE(sldns_buffer_begin(c->buffer))
1710b7579f77SDag-Erling Smørgrav 				== LDNS_RCODE_NXDOMAIN)) {
1711b7579f77SDag-Erling Smørgrav 			verbose(VERB_DETAIL, "no qname in reply to check 0x20ID");
1712b7579f77SDag-Erling Smørgrav 			log_addr(VERB_DETAIL, "from server",
1713b7579f77SDag-Erling Smørgrav 				&sq->addr, sq->addrlen);
1714b7579f77SDag-Erling Smørgrav 			log_buf(VERB_DETAIL, "for packet", c->buffer);
1715b7579f77SDag-Erling Smørgrav 			error = NETEVENT_CLOSED;
1716b7579f77SDag-Erling Smørgrav 			c = NULL;
171717d15b25SDag-Erling Smørgrav 		} else if(sldns_buffer_read_u16_at(c->buffer, 4) > 0 &&
1718b7579f77SDag-Erling Smørgrav 			!serviced_check_qname(c->buffer, sq->qbuf,
1719b7579f77SDag-Erling Smørgrav 			sq->qbuflen)) {
1720b7579f77SDag-Erling Smørgrav 			verbose(VERB_DETAIL, "wrong 0x20-ID in reply qname");
1721b7579f77SDag-Erling Smørgrav 			log_addr(VERB_DETAIL, "from server",
1722b7579f77SDag-Erling Smørgrav 				&sq->addr, sq->addrlen);
1723b7579f77SDag-Erling Smørgrav 			log_buf(VERB_DETAIL, "for packet", c->buffer);
1724b7579f77SDag-Erling Smørgrav 			error = NETEVENT_CAPSFAIL;
1725b7579f77SDag-Erling Smørgrav 			/* and cleanup too */
1726b7579f77SDag-Erling Smørgrav 			pkt_dname_tolower(c->buffer,
172717d15b25SDag-Erling Smørgrav 				sldns_buffer_at(c->buffer, 12));
1728b7579f77SDag-Erling Smørgrav 		} else {
1729b7579f77SDag-Erling Smørgrav 			verbose(VERB_ALGO, "good 0x20-ID in reply qname");
1730b7579f77SDag-Erling Smørgrav 			/* cleanup caps, prettier cache contents. */
1731b7579f77SDag-Erling Smørgrav 			pkt_dname_tolower(c->buffer,
173217d15b25SDag-Erling Smørgrav 				sldns_buffer_at(c->buffer, 12));
1733b7579f77SDag-Erling Smørgrav 		}
1734b7579f77SDag-Erling Smørgrav 	}
1735b7579f77SDag-Erling Smørgrav 	if(dobackup && c) {
1736b7579f77SDag-Erling Smørgrav 		/* make a backup of the query, since the querystate processing
1737b7579f77SDag-Erling Smørgrav 		 * may send outgoing queries that overwrite the buffer.
1738b7579f77SDag-Erling Smørgrav 		 * use secondary buffer to store the query.
1739b7579f77SDag-Erling Smørgrav 		 * This is a data copy, but faster than packet to server */
174017d15b25SDag-Erling Smørgrav 		backlen = sldns_buffer_limit(c->buffer);
174117d15b25SDag-Erling Smørgrav 		backup_p = memdup(sldns_buffer_begin(c->buffer), backlen);
1742b7579f77SDag-Erling Smørgrav 		if(!backup_p) {
1743b7579f77SDag-Erling Smørgrav 			log_err("malloc failure in serviced query callbacks");
1744b7579f77SDag-Erling Smørgrav 			error = NETEVENT_CLOSED;
1745b7579f77SDag-Erling Smørgrav 			c = NULL;
1746b7579f77SDag-Erling Smørgrav 		}
1747b7579f77SDag-Erling Smørgrav 		sq->outnet->svcd_overhead = backlen;
1748b7579f77SDag-Erling Smørgrav 	}
17498ed2b524SDag-Erling Smørgrav 	/* test the actual sq->cblist, because the next elem could be deleted*/
17508ed2b524SDag-Erling Smørgrav 	while((p=sq->cblist) != NULL) {
17518ed2b524SDag-Erling Smørgrav 		sq->cblist = p->next; /* remove this element */
1752b7579f77SDag-Erling Smørgrav 		if(dobackup && c) {
175317d15b25SDag-Erling Smørgrav 			sldns_buffer_clear(c->buffer);
175417d15b25SDag-Erling Smørgrav 			sldns_buffer_write(c->buffer, backup_p, backlen);
175517d15b25SDag-Erling Smørgrav 			sldns_buffer_flip(c->buffer);
1756b7579f77SDag-Erling Smørgrav 		}
1757b7579f77SDag-Erling Smørgrav 		fptr_ok(fptr_whitelist_serviced_query(p->cb));
1758b7579f77SDag-Erling Smørgrav 		(void)(*p->cb)(c, p->cb_arg, error, rep);
17598ed2b524SDag-Erling Smørgrav 		free(p);
1760b7579f77SDag-Erling Smørgrav 	}
1761b7579f77SDag-Erling Smørgrav 	if(backup_p) {
1762b7579f77SDag-Erling Smørgrav 		free(backup_p);
1763b7579f77SDag-Erling Smørgrav 		sq->outnet->svcd_overhead = 0;
1764b7579f77SDag-Erling Smørgrav 	}
1765b7579f77SDag-Erling Smørgrav 	verbose(VERB_ALGO, "svcd callbacks end");
1766b7579f77SDag-Erling Smørgrav 	log_assert(sq->cblist == NULL);
1767b7579f77SDag-Erling Smørgrav 	serviced_delete(sq);
1768b7579f77SDag-Erling Smørgrav }
1769b7579f77SDag-Erling Smørgrav 
1770b7579f77SDag-Erling Smørgrav int
1771b7579f77SDag-Erling Smørgrav serviced_tcp_callback(struct comm_point* c, void* arg, int error,
1772b7579f77SDag-Erling Smørgrav         struct comm_reply* rep)
1773b7579f77SDag-Erling Smørgrav {
1774b7579f77SDag-Erling Smørgrav 	struct serviced_query* sq = (struct serviced_query*)arg;
1775b7579f77SDag-Erling Smørgrav 	struct comm_reply r2;
1776b7579f77SDag-Erling Smørgrav 	sq->pending = NULL; /* removed after this callback */
1777b7579f77SDag-Erling Smørgrav 	if(error != NETEVENT_NOERROR)
1778b7579f77SDag-Erling Smørgrav 		log_addr(VERB_QUERY, "tcp error for address",
1779b7579f77SDag-Erling Smørgrav 			&sq->addr, sq->addrlen);
1780b7579f77SDag-Erling Smørgrav 	if(error==NETEVENT_NOERROR)
1781b7579f77SDag-Erling Smørgrav 		infra_update_tcp_works(sq->outnet->infra, &sq->addr,
1782b7579f77SDag-Erling Smørgrav 			sq->addrlen, sq->zone, sq->zonelen);
1783ff825849SDag-Erling Smørgrav #ifdef USE_DNSTAP
178409a3aaf3SDag-Erling Smørgrav 	if(error==NETEVENT_NOERROR && sq->outnet->dtenv &&
1785ff825849SDag-Erling Smørgrav 	   (sq->outnet->dtenv->log_resolver_response_messages ||
1786ff825849SDag-Erling Smørgrav 	    sq->outnet->dtenv->log_forwarder_response_messages))
1787ff825849SDag-Erling Smørgrav 		dt_msg_send_outside_response(sq->outnet->dtenv, &sq->addr,
1788ff825849SDag-Erling Smørgrav 		c->type, sq->zone, sq->zonelen, sq->qbuf, sq->qbuflen,
1789ff825849SDag-Erling Smørgrav 		&sq->last_sent_time, sq->outnet->now_tv, c->buffer);
1790ff825849SDag-Erling Smørgrav #endif
1791b7579f77SDag-Erling Smørgrav 	if(error==NETEVENT_NOERROR && sq->status == serviced_query_TCP_EDNS &&
179217d15b25SDag-Erling Smørgrav 		(LDNS_RCODE_WIRE(sldns_buffer_begin(c->buffer)) ==
179317d15b25SDag-Erling Smørgrav 		LDNS_RCODE_FORMERR || LDNS_RCODE_WIRE(sldns_buffer_begin(
1794b7579f77SDag-Erling Smørgrav 		c->buffer)) == LDNS_RCODE_NOTIMPL) ) {
1795b7579f77SDag-Erling Smørgrav 		/* attempt to fallback to nonEDNS */
1796b7579f77SDag-Erling Smørgrav 		sq->status = serviced_query_TCP_EDNS_fallback;
1797ff825849SDag-Erling Smørgrav 		serviced_tcp_initiate(sq, c->buffer);
1798b7579f77SDag-Erling Smørgrav 		return 0;
1799b7579f77SDag-Erling Smørgrav 	} else if(error==NETEVENT_NOERROR &&
1800b7579f77SDag-Erling Smørgrav 		sq->status == serviced_query_TCP_EDNS_fallback &&
180117d15b25SDag-Erling Smørgrav 			(LDNS_RCODE_WIRE(sldns_buffer_begin(c->buffer)) ==
1802b7579f77SDag-Erling Smørgrav 			LDNS_RCODE_NOERROR || LDNS_RCODE_WIRE(
180317d15b25SDag-Erling Smørgrav 			sldns_buffer_begin(c->buffer)) == LDNS_RCODE_NXDOMAIN
180417d15b25SDag-Erling Smørgrav 			|| LDNS_RCODE_WIRE(sldns_buffer_begin(c->buffer))
1805b7579f77SDag-Erling Smørgrav 			== LDNS_RCODE_YXDOMAIN)) {
1806b7579f77SDag-Erling Smørgrav 		/* the fallback produced a result that looks promising, note
1807b7579f77SDag-Erling Smørgrav 		 * that this server should be approached without EDNS */
1808b7579f77SDag-Erling Smørgrav 		/* only store noEDNS in cache if domain is noDNSSEC */
1809b7579f77SDag-Erling Smørgrav 		if(!sq->want_dnssec)
1810b7579f77SDag-Erling Smørgrav 		  if(!infra_edns_update(sq->outnet->infra, &sq->addr,
1811b7579f77SDag-Erling Smørgrav 			sq->addrlen, sq->zone, sq->zonelen, -1,
1812b7579f77SDag-Erling Smørgrav 			*sq->outnet->now_secs))
1813b7579f77SDag-Erling Smørgrav 			log_err("Out of memory caching no edns for host");
1814b7579f77SDag-Erling Smørgrav 		sq->status = serviced_query_TCP;
1815b7579f77SDag-Erling Smørgrav 	}
1816b7579f77SDag-Erling Smørgrav 	if(sq->tcp_upstream || sq->ssl_upstream) {
1817b7579f77SDag-Erling Smørgrav 	    struct timeval now = *sq->outnet->now_tv;
18183bd4df0aSDag-Erling Smørgrav 	    if(error!=NETEVENT_NOERROR) {
18193bd4df0aSDag-Erling Smørgrav 	        if(!infra_rtt_update(sq->outnet->infra, &sq->addr,
18203bd4df0aSDag-Erling Smørgrav 		    sq->addrlen, sq->zone, sq->zonelen, sq->qtype,
18213bd4df0aSDag-Erling Smørgrav 		    -1, sq->last_rtt, (time_t)now.tv_sec))
18223bd4df0aSDag-Erling Smørgrav 		    log_err("out of memory in TCP exponential backoff.");
18233bd4df0aSDag-Erling Smørgrav 	    } else if(now.tv_sec > sq->last_sent_time.tv_sec ||
1824b7579f77SDag-Erling Smørgrav 		(now.tv_sec == sq->last_sent_time.tv_sec &&
1825b7579f77SDag-Erling Smørgrav 		now.tv_usec > sq->last_sent_time.tv_usec)) {
1826b7579f77SDag-Erling Smørgrav 		/* convert from microseconds to milliseconds */
182717d15b25SDag-Erling Smørgrav 		int roundtime = ((int)(now.tv_sec - sq->last_sent_time.tv_sec))*1000
1828b7579f77SDag-Erling Smørgrav 		  + ((int)now.tv_usec - (int)sq->last_sent_time.tv_usec)/1000;
1829b7579f77SDag-Erling Smørgrav 		verbose(VERB_ALGO, "measured TCP-time at %d msec", roundtime);
1830b7579f77SDag-Erling Smørgrav 		log_assert(roundtime >= 0);
1831b7579f77SDag-Erling Smørgrav 		/* only store if less then AUTH_TIMEOUT seconds, it could be
1832b7579f77SDag-Erling Smørgrav 		 * huge due to system-hibernated and we woke up */
18333bd4df0aSDag-Erling Smørgrav 		if(roundtime < 60000) {
1834b7579f77SDag-Erling Smørgrav 		    if(!infra_rtt_update(sq->outnet->infra, &sq->addr,
1835b7579f77SDag-Erling Smørgrav 			sq->addrlen, sq->zone, sq->zonelen, sq->qtype,
183617d15b25SDag-Erling Smørgrav 			roundtime, sq->last_rtt, (time_t)now.tv_sec))
1837b7579f77SDag-Erling Smørgrav 			log_err("out of memory noting rtt.");
1838b7579f77SDag-Erling Smørgrav 		}
1839b7579f77SDag-Erling Smørgrav 	    }
1840b7579f77SDag-Erling Smørgrav 	}
1841b7579f77SDag-Erling Smørgrav 	/* insert address into reply info */
1842b7579f77SDag-Erling Smørgrav 	if(!rep) {
1843b7579f77SDag-Erling Smørgrav 		/* create one if there isn't (on errors) */
1844b7579f77SDag-Erling Smørgrav 		rep = &r2;
1845b7579f77SDag-Erling Smørgrav 		r2.c = c;
1846b7579f77SDag-Erling Smørgrav 	}
1847b7579f77SDag-Erling Smørgrav 	memcpy(&rep->addr, &sq->addr, sq->addrlen);
1848b7579f77SDag-Erling Smørgrav 	rep->addrlen = sq->addrlen;
1849b7579f77SDag-Erling Smørgrav 	serviced_callbacks(sq, error, c, rep);
1850b7579f77SDag-Erling Smørgrav 	return 0;
1851b7579f77SDag-Erling Smørgrav }
1852b7579f77SDag-Erling Smørgrav 
1853b7579f77SDag-Erling Smørgrav static void
1854ff825849SDag-Erling Smørgrav serviced_tcp_initiate(struct serviced_query* sq, sldns_buffer* buff)
1855b7579f77SDag-Erling Smørgrav {
1856b7579f77SDag-Erling Smørgrav 	verbose(VERB_ALGO, "initiate TCP query %s",
1857b7579f77SDag-Erling Smørgrav 		sq->status==serviced_query_TCP_EDNS?"EDNS":"");
1858b7579f77SDag-Erling Smørgrav 	serviced_encode(sq, buff, sq->status == serviced_query_TCP_EDNS);
1859b7579f77SDag-Erling Smørgrav 	sq->last_sent_time = *sq->outnet->now_tv;
1860ff825849SDag-Erling Smørgrav 	sq->pending = pending_tcp_query(sq, buff, TCP_AUTH_QUERY_TIMEOUT,
1861ff825849SDag-Erling Smørgrav 		serviced_tcp_callback, sq);
1862b7579f77SDag-Erling Smørgrav 	if(!sq->pending) {
1863b7579f77SDag-Erling Smørgrav 		/* delete from tree so that a retry by above layer does not
1864b7579f77SDag-Erling Smørgrav 		 * clash with this entry */
1865b7579f77SDag-Erling Smørgrav 		log_err("serviced_tcp_initiate: failed to send tcp query");
1866b7579f77SDag-Erling Smørgrav 		serviced_callbacks(sq, NETEVENT_CLOSED, NULL, NULL);
1867b7579f77SDag-Erling Smørgrav 	}
1868b7579f77SDag-Erling Smørgrav }
1869b7579f77SDag-Erling Smørgrav 
1870b7579f77SDag-Erling Smørgrav /** Send serviced query over TCP return false on initial failure */
1871b7579f77SDag-Erling Smørgrav static int
187217d15b25SDag-Erling Smørgrav serviced_tcp_send(struct serviced_query* sq, sldns_buffer* buff)
1873b7579f77SDag-Erling Smørgrav {
18743bd4df0aSDag-Erling Smørgrav 	int vs, rtt, timeout;
1875b7579f77SDag-Erling Smørgrav 	uint8_t edns_lame_known;
1876b7579f77SDag-Erling Smørgrav 	if(!infra_host(sq->outnet->infra, &sq->addr, sq->addrlen, sq->zone,
1877b7579f77SDag-Erling Smørgrav 		sq->zonelen, *sq->outnet->now_secs, &vs, &edns_lame_known,
1878b7579f77SDag-Erling Smørgrav 		&rtt))
1879b7579f77SDag-Erling Smørgrav 		return 0;
18803bd4df0aSDag-Erling Smørgrav 	sq->last_rtt = rtt;
1881b7579f77SDag-Erling Smørgrav 	if(vs != -1)
1882b7579f77SDag-Erling Smørgrav 		sq->status = serviced_query_TCP_EDNS;
1883b7579f77SDag-Erling Smørgrav 	else 	sq->status = serviced_query_TCP;
1884b7579f77SDag-Erling Smørgrav 	serviced_encode(sq, buff, sq->status == serviced_query_TCP_EDNS);
1885b7579f77SDag-Erling Smørgrav 	sq->last_sent_time = *sq->outnet->now_tv;
18863bd4df0aSDag-Erling Smørgrav 	if(sq->tcp_upstream || sq->ssl_upstream) {
18873bd4df0aSDag-Erling Smørgrav 		timeout = rtt;
1888*4c75e3aaSDag-Erling Smørgrav 		if(rtt >= UNKNOWN_SERVER_NICENESS && rtt < TCP_AUTH_QUERY_TIMEOUT)
18893bd4df0aSDag-Erling Smørgrav 			timeout = TCP_AUTH_QUERY_TIMEOUT;
18903bd4df0aSDag-Erling Smørgrav 	} else {
18913bd4df0aSDag-Erling Smørgrav 		timeout = TCP_AUTH_QUERY_TIMEOUT;
18923bd4df0aSDag-Erling Smørgrav 	}
18933bd4df0aSDag-Erling Smørgrav 	sq->pending = pending_tcp_query(sq, buff, timeout,
1894ff825849SDag-Erling Smørgrav 		serviced_tcp_callback, sq);
1895b7579f77SDag-Erling Smørgrav 	return sq->pending != NULL;
1896b7579f77SDag-Erling Smørgrav }
1897b7579f77SDag-Erling Smørgrav 
1898e2d15004SDag-Erling Smørgrav /* see if packet is edns malformed; got zeroes at start.
1899e2d15004SDag-Erling Smørgrav  * This is from servers that return malformed packets to EDNS0 queries,
1900e2d15004SDag-Erling Smørgrav  * but they return good packets for nonEDNS0 queries.
1901e2d15004SDag-Erling Smørgrav  * We try to detect their output; without resorting to a full parse or
1902e2d15004SDag-Erling Smørgrav  * check for too many bytes after the end of the packet. */
1903e2d15004SDag-Erling Smørgrav static int
1904e2d15004SDag-Erling Smørgrav packet_edns_malformed(struct sldns_buffer* buf, int qtype)
1905e2d15004SDag-Erling Smørgrav {
1906e2d15004SDag-Erling Smørgrav 	size_t len;
1907e2d15004SDag-Erling Smørgrav 	if(sldns_buffer_limit(buf) < LDNS_HEADER_SIZE)
1908e2d15004SDag-Erling Smørgrav 		return 1; /* malformed */
1909e2d15004SDag-Erling Smørgrav 	/* they have NOERROR rcode, 1 answer. */
1910e2d15004SDag-Erling Smørgrav 	if(LDNS_RCODE_WIRE(sldns_buffer_begin(buf)) != LDNS_RCODE_NOERROR)
1911e2d15004SDag-Erling Smørgrav 		return 0;
1912e2d15004SDag-Erling Smørgrav 	/* one query (to skip) and answer records */
1913e2d15004SDag-Erling Smørgrav 	if(LDNS_QDCOUNT(sldns_buffer_begin(buf)) != 1 ||
1914e2d15004SDag-Erling Smørgrav 		LDNS_ANCOUNT(sldns_buffer_begin(buf)) == 0)
1915e2d15004SDag-Erling Smørgrav 		return 0;
1916e2d15004SDag-Erling Smørgrav 	/* skip qname */
1917e2d15004SDag-Erling Smørgrav 	len = dname_valid(sldns_buffer_at(buf, LDNS_HEADER_SIZE),
1918e2d15004SDag-Erling Smørgrav 		sldns_buffer_limit(buf)-LDNS_HEADER_SIZE);
1919e2d15004SDag-Erling Smørgrav 	if(len == 0)
1920e2d15004SDag-Erling Smørgrav 		return 0;
1921e2d15004SDag-Erling Smørgrav 	if(len == 1 && qtype == 0)
1922e2d15004SDag-Erling Smørgrav 		return 0; /* we asked for '.' and type 0 */
1923e2d15004SDag-Erling Smørgrav 	/* and then 4 bytes (type and class of query) */
1924e2d15004SDag-Erling Smørgrav 	if(sldns_buffer_limit(buf) < LDNS_HEADER_SIZE + len + 4 + 3)
1925e2d15004SDag-Erling Smørgrav 		return 0;
1926e2d15004SDag-Erling Smørgrav 
1927e2d15004SDag-Erling Smørgrav 	/* and start with 11 zeroes as the answer RR */
1928e2d15004SDag-Erling Smørgrav 	/* so check the qtype of the answer record, qname=0, type=0 */
1929e2d15004SDag-Erling Smørgrav 	if(sldns_buffer_at(buf, LDNS_HEADER_SIZE+len+4)[0] == 0 &&
1930e2d15004SDag-Erling Smørgrav 	   sldns_buffer_at(buf, LDNS_HEADER_SIZE+len+4)[1] == 0 &&
1931e2d15004SDag-Erling Smørgrav 	   sldns_buffer_at(buf, LDNS_HEADER_SIZE+len+4)[2] == 0)
1932e2d15004SDag-Erling Smørgrav 		return 1;
1933e2d15004SDag-Erling Smørgrav 	return 0;
1934e2d15004SDag-Erling Smørgrav }
1935e2d15004SDag-Erling Smørgrav 
1936b7579f77SDag-Erling Smørgrav int
1937b7579f77SDag-Erling Smørgrav serviced_udp_callback(struct comm_point* c, void* arg, int error,
1938b7579f77SDag-Erling Smørgrav         struct comm_reply* rep)
1939b7579f77SDag-Erling Smørgrav {
1940b7579f77SDag-Erling Smørgrav 	struct serviced_query* sq = (struct serviced_query*)arg;
1941b7579f77SDag-Erling Smørgrav 	struct outside_network* outnet = sq->outnet;
1942b7579f77SDag-Erling Smørgrav 	struct timeval now = *sq->outnet->now_tv;
1943b7579f77SDag-Erling Smørgrav 	int fallback_tcp = 0;
1944b7579f77SDag-Erling Smørgrav 
1945b7579f77SDag-Erling Smørgrav 	sq->pending = NULL; /* removed after callback */
1946b7579f77SDag-Erling Smørgrav 	if(error == NETEVENT_TIMEOUT) {
1947b7579f77SDag-Erling Smørgrav 		int rto = 0;
1948b7579f77SDag-Erling Smørgrav 		if(sq->status == serviced_query_PROBE_EDNS) {
1949b7579f77SDag-Erling Smørgrav 			/* non-EDNS probe failed; we do not know its status,
1950b7579f77SDag-Erling Smørgrav 			 * keep trying with EDNS, timeout may not be caused
1951b7579f77SDag-Erling Smørgrav 			 * by EDNS. */
1952b7579f77SDag-Erling Smørgrav 			sq->status = serviced_query_UDP_EDNS;
1953b7579f77SDag-Erling Smørgrav 		}
1954b7579f77SDag-Erling Smørgrav 		if(sq->status == serviced_query_UDP_EDNS && sq->last_rtt < 5000) {
1955b7579f77SDag-Erling Smørgrav 			/* fallback to 1480/1280 */
1956b7579f77SDag-Erling Smørgrav 			sq->status = serviced_query_UDP_EDNS_FRAG;
1957b7579f77SDag-Erling Smørgrav 			log_name_addr(VERB_ALGO, "try edns1xx0", sq->qbuf+10,
1958b7579f77SDag-Erling Smørgrav 				&sq->addr, sq->addrlen);
1959b7579f77SDag-Erling Smørgrav 			if(!serviced_udp_send(sq, c->buffer)) {
1960b7579f77SDag-Erling Smørgrav 				serviced_callbacks(sq, NETEVENT_CLOSED, c, rep);
1961b7579f77SDag-Erling Smørgrav 			}
1962b7579f77SDag-Erling Smørgrav 			return 0;
1963b7579f77SDag-Erling Smørgrav 		}
1964b7579f77SDag-Erling Smørgrav 		if(sq->status == serviced_query_UDP_EDNS_FRAG) {
1965b7579f77SDag-Erling Smørgrav 			/* fragmentation size did not fix it */
1966b7579f77SDag-Erling Smørgrav 			sq->status = serviced_query_UDP_EDNS;
1967b7579f77SDag-Erling Smørgrav 		}
1968b7579f77SDag-Erling Smørgrav 		sq->retry++;
1969b7579f77SDag-Erling Smørgrav 		if(!(rto=infra_rtt_update(outnet->infra, &sq->addr, sq->addrlen,
1970b7579f77SDag-Erling Smørgrav 			sq->zone, sq->zonelen, sq->qtype, -1, sq->last_rtt,
197117d15b25SDag-Erling Smørgrav 			(time_t)now.tv_sec)))
1972b7579f77SDag-Erling Smørgrav 			log_err("out of memory in UDP exponential backoff");
1973b7579f77SDag-Erling Smørgrav 		if(sq->retry < OUTBOUND_UDP_RETRY) {
1974b7579f77SDag-Erling Smørgrav 			log_name_addr(VERB_ALGO, "retry query", sq->qbuf+10,
1975b7579f77SDag-Erling Smørgrav 				&sq->addr, sq->addrlen);
1976b7579f77SDag-Erling Smørgrav 			if(!serviced_udp_send(sq, c->buffer)) {
1977b7579f77SDag-Erling Smørgrav 				serviced_callbacks(sq, NETEVENT_CLOSED, c, rep);
1978b7579f77SDag-Erling Smørgrav 			}
1979b7579f77SDag-Erling Smørgrav 			return 0;
1980b7579f77SDag-Erling Smørgrav 		}
1981b7579f77SDag-Erling Smørgrav 		if(rto >= RTT_MAX_TIMEOUT) {
1982b7579f77SDag-Erling Smørgrav 			fallback_tcp = 1;
1983b7579f77SDag-Erling Smørgrav 			/* UDP does not work, fallback to TCP below */
1984b7579f77SDag-Erling Smørgrav 		} else {
1985b7579f77SDag-Erling Smørgrav 			serviced_callbacks(sq, NETEVENT_TIMEOUT, c, rep);
1986b7579f77SDag-Erling Smørgrav 			return 0;
1987b7579f77SDag-Erling Smørgrav 		}
1988b7579f77SDag-Erling Smørgrav 	} else if(error != NETEVENT_NOERROR) {
1989b7579f77SDag-Erling Smørgrav 		/* udp returns error (due to no ID or interface available) */
1990b7579f77SDag-Erling Smørgrav 		serviced_callbacks(sq, error, c, rep);
1991b7579f77SDag-Erling Smørgrav 		return 0;
1992b7579f77SDag-Erling Smørgrav 	}
1993ff825849SDag-Erling Smørgrav #ifdef USE_DNSTAP
1994bc892140SDag-Erling Smørgrav 	if(error == NETEVENT_NOERROR && outnet->dtenv &&
1995ff825849SDag-Erling Smørgrav 	   (outnet->dtenv->log_resolver_response_messages ||
1996ff825849SDag-Erling Smørgrav 	    outnet->dtenv->log_forwarder_response_messages))
1997ff825849SDag-Erling Smørgrav 		dt_msg_send_outside_response(outnet->dtenv, &sq->addr, c->type,
1998ff825849SDag-Erling Smørgrav 		sq->zone, sq->zonelen, sq->qbuf, sq->qbuflen,
1999ff825849SDag-Erling Smørgrav 		&sq->last_sent_time, sq->outnet->now_tv, c->buffer);
2000ff825849SDag-Erling Smørgrav #endif
2001b7579f77SDag-Erling Smørgrav 	if(!fallback_tcp) {
2002b7579f77SDag-Erling Smørgrav 	    if( (sq->status == serviced_query_UDP_EDNS
2003b7579f77SDag-Erling Smørgrav 	        ||sq->status == serviced_query_UDP_EDNS_FRAG)
200417d15b25SDag-Erling Smørgrav 		&& (LDNS_RCODE_WIRE(sldns_buffer_begin(c->buffer))
2005b7579f77SDag-Erling Smørgrav 			== LDNS_RCODE_FORMERR || LDNS_RCODE_WIRE(
2006e2d15004SDag-Erling Smørgrav 			sldns_buffer_begin(c->buffer)) == LDNS_RCODE_NOTIMPL
2007e2d15004SDag-Erling Smørgrav 		    || packet_edns_malformed(c->buffer, sq->qtype)
2008e2d15004SDag-Erling Smørgrav 			)) {
2009b7579f77SDag-Erling Smørgrav 		/* try to get an answer by falling back without EDNS */
2010b7579f77SDag-Erling Smørgrav 		verbose(VERB_ALGO, "serviced query: attempt without EDNS");
2011b7579f77SDag-Erling Smørgrav 		sq->status = serviced_query_UDP_EDNS_fallback;
2012b7579f77SDag-Erling Smørgrav 		sq->retry = 0;
2013b7579f77SDag-Erling Smørgrav 		if(!serviced_udp_send(sq, c->buffer)) {
2014b7579f77SDag-Erling Smørgrav 			serviced_callbacks(sq, NETEVENT_CLOSED, c, rep);
2015b7579f77SDag-Erling Smørgrav 		}
2016b7579f77SDag-Erling Smørgrav 		return 0;
2017b7579f77SDag-Erling Smørgrav 	    } else if(sq->status == serviced_query_PROBE_EDNS) {
2018b7579f77SDag-Erling Smørgrav 		/* probe without EDNS succeeds, so we conclude that this
2019b7579f77SDag-Erling Smørgrav 		 * host likely has EDNS packets dropped */
2020b7579f77SDag-Erling Smørgrav 		log_addr(VERB_DETAIL, "timeouts, concluded that connection to "
2021b7579f77SDag-Erling Smørgrav 			"host drops EDNS packets", &sq->addr, sq->addrlen);
2022b7579f77SDag-Erling Smørgrav 		/* only store noEDNS in cache if domain is noDNSSEC */
2023b7579f77SDag-Erling Smørgrav 		if(!sq->want_dnssec)
2024b7579f77SDag-Erling Smørgrav 		  if(!infra_edns_update(outnet->infra, &sq->addr, sq->addrlen,
202517d15b25SDag-Erling Smørgrav 			sq->zone, sq->zonelen, -1, (time_t)now.tv_sec)) {
2026b7579f77SDag-Erling Smørgrav 			log_err("Out of memory caching no edns for host");
2027b7579f77SDag-Erling Smørgrav 		  }
2028b7579f77SDag-Erling Smørgrav 		sq->status = serviced_query_UDP;
2029b7579f77SDag-Erling Smørgrav 	    } else if(sq->status == serviced_query_UDP_EDNS &&
2030b7579f77SDag-Erling Smørgrav 		!sq->edns_lame_known) {
2031b7579f77SDag-Erling Smørgrav 		/* now we know that edns queries received answers store that */
2032b7579f77SDag-Erling Smørgrav 		log_addr(VERB_ALGO, "serviced query: EDNS works for",
2033b7579f77SDag-Erling Smørgrav 			&sq->addr, sq->addrlen);
2034b7579f77SDag-Erling Smørgrav 		if(!infra_edns_update(outnet->infra, &sq->addr, sq->addrlen,
203517d15b25SDag-Erling Smørgrav 			sq->zone, sq->zonelen, 0, (time_t)now.tv_sec)) {
2036b7579f77SDag-Erling Smørgrav 			log_err("Out of memory caching edns works");
2037b7579f77SDag-Erling Smørgrav 		}
2038b7579f77SDag-Erling Smørgrav 		sq->edns_lame_known = 1;
2039b7579f77SDag-Erling Smørgrav 	    } else if(sq->status == serviced_query_UDP_EDNS_fallback &&
2040b7579f77SDag-Erling Smørgrav 		!sq->edns_lame_known && (LDNS_RCODE_WIRE(
204117d15b25SDag-Erling Smørgrav 		sldns_buffer_begin(c->buffer)) == LDNS_RCODE_NOERROR ||
204217d15b25SDag-Erling Smørgrav 		LDNS_RCODE_WIRE(sldns_buffer_begin(c->buffer)) ==
204317d15b25SDag-Erling Smørgrav 		LDNS_RCODE_NXDOMAIN || LDNS_RCODE_WIRE(sldns_buffer_begin(
2044b7579f77SDag-Erling Smørgrav 		c->buffer)) == LDNS_RCODE_YXDOMAIN)) {
2045b7579f77SDag-Erling Smørgrav 		/* the fallback produced a result that looks promising, note
2046b7579f77SDag-Erling Smørgrav 		 * that this server should be approached without EDNS */
2047b7579f77SDag-Erling Smørgrav 		/* only store noEDNS in cache if domain is noDNSSEC */
2048b7579f77SDag-Erling Smørgrav 		if(!sq->want_dnssec) {
2049b7579f77SDag-Erling Smørgrav 		  log_addr(VERB_ALGO, "serviced query: EDNS fails for",
2050b7579f77SDag-Erling Smørgrav 			&sq->addr, sq->addrlen);
2051b7579f77SDag-Erling Smørgrav 		  if(!infra_edns_update(outnet->infra, &sq->addr, sq->addrlen,
205217d15b25SDag-Erling Smørgrav 			sq->zone, sq->zonelen, -1, (time_t)now.tv_sec)) {
2053b7579f77SDag-Erling Smørgrav 			log_err("Out of memory caching no edns for host");
2054b7579f77SDag-Erling Smørgrav 		  }
2055b7579f77SDag-Erling Smørgrav 		} else {
2056b7579f77SDag-Erling Smørgrav 		  log_addr(VERB_ALGO, "serviced query: EDNS fails, but "
2057b7579f77SDag-Erling Smørgrav 		  	"not stored because need DNSSEC for", &sq->addr,
2058b7579f77SDag-Erling Smørgrav 			sq->addrlen);
2059b7579f77SDag-Erling Smørgrav 		}
2060b7579f77SDag-Erling Smørgrav 		sq->status = serviced_query_UDP;
2061b7579f77SDag-Erling Smørgrav 	    }
2062b7579f77SDag-Erling Smørgrav 	    if(now.tv_sec > sq->last_sent_time.tv_sec ||
2063b7579f77SDag-Erling Smørgrav 		(now.tv_sec == sq->last_sent_time.tv_sec &&
2064b7579f77SDag-Erling Smørgrav 		now.tv_usec > sq->last_sent_time.tv_usec)) {
2065b7579f77SDag-Erling Smørgrav 		/* convert from microseconds to milliseconds */
206617d15b25SDag-Erling Smørgrav 		int roundtime = ((int)(now.tv_sec - sq->last_sent_time.tv_sec))*1000
2067b7579f77SDag-Erling Smørgrav 		  + ((int)now.tv_usec - (int)sq->last_sent_time.tv_usec)/1000;
2068b7579f77SDag-Erling Smørgrav 		verbose(VERB_ALGO, "measured roundtrip at %d msec", roundtime);
2069b7579f77SDag-Erling Smørgrav 		log_assert(roundtime >= 0);
2070b7579f77SDag-Erling Smørgrav 		/* in case the system hibernated, do not enter a huge value,
2071b7579f77SDag-Erling Smørgrav 		 * above this value gives trouble with server selection */
2072b7579f77SDag-Erling Smørgrav 		if(roundtime < 60000) {
2073b7579f77SDag-Erling Smørgrav 		    if(!infra_rtt_update(outnet->infra, &sq->addr, sq->addrlen,
2074b7579f77SDag-Erling Smørgrav 			sq->zone, sq->zonelen, sq->qtype, roundtime,
207517d15b25SDag-Erling Smørgrav 			sq->last_rtt, (time_t)now.tv_sec))
2076b7579f77SDag-Erling Smørgrav 			log_err("out of memory noting rtt.");
2077b7579f77SDag-Erling Smørgrav 		}
2078b7579f77SDag-Erling Smørgrav 	    }
2079b7579f77SDag-Erling Smørgrav 	} /* end of if_!fallback_tcp */
2080b7579f77SDag-Erling Smørgrav 	/* perform TC flag check and TCP fallback after updating our
2081b7579f77SDag-Erling Smørgrav 	 * cache entries for EDNS status and RTT times */
208217d15b25SDag-Erling Smørgrav 	if(LDNS_TC_WIRE(sldns_buffer_begin(c->buffer)) || fallback_tcp) {
2083b7579f77SDag-Erling Smørgrav 		/* fallback to TCP */
2084b7579f77SDag-Erling Smørgrav 		/* this discards partial UDP contents */
2085b7579f77SDag-Erling Smørgrav 		if(sq->status == serviced_query_UDP_EDNS ||
2086b7579f77SDag-Erling Smørgrav 			sq->status == serviced_query_UDP_EDNS_FRAG ||
2087b7579f77SDag-Erling Smørgrav 			sq->status == serviced_query_UDP_EDNS_fallback)
2088b7579f77SDag-Erling Smørgrav 			/* if we have unfinished EDNS_fallback, start again */
2089b7579f77SDag-Erling Smørgrav 			sq->status = serviced_query_TCP_EDNS;
2090b7579f77SDag-Erling Smørgrav 		else	sq->status = serviced_query_TCP;
2091ff825849SDag-Erling Smørgrav 		serviced_tcp_initiate(sq, c->buffer);
2092b7579f77SDag-Erling Smørgrav 		return 0;
2093b7579f77SDag-Erling Smørgrav 	}
2094b7579f77SDag-Erling Smørgrav 	/* yay! an answer */
2095b7579f77SDag-Erling Smørgrav 	serviced_callbacks(sq, error, c, rep);
2096b7579f77SDag-Erling Smørgrav 	return 0;
2097b7579f77SDag-Erling Smørgrav }
2098b7579f77SDag-Erling Smørgrav 
2099b7579f77SDag-Erling Smørgrav struct serviced_query*
2100b7579f77SDag-Erling Smørgrav outnet_serviced_query(struct outside_network* outnet,
2101bc892140SDag-Erling Smørgrav 	struct query_info* qinfo, uint16_t flags, int dnssec, int want_dnssec,
21020fb34990SDag-Erling Smørgrav 	int nocaps, int tcp_upstream, int ssl_upstream, char* tls_auth_name,
2103e2d15004SDag-Erling Smørgrav 	struct sockaddr_storage* addr, socklen_t addrlen, uint8_t* zone,
2104bc892140SDag-Erling Smørgrav 	size_t zonelen, struct module_qstate* qstate,
21053005e0a3SDag-Erling Smørgrav 	comm_point_callback_type* callback, void* callback_arg, sldns_buffer* buff,
2106bc892140SDag-Erling Smørgrav 	struct module_env* env)
2107b7579f77SDag-Erling Smørgrav {
2108b7579f77SDag-Erling Smørgrav 	struct serviced_query* sq;
2109b7579f77SDag-Erling Smørgrav 	struct service_callback* cb;
2110bc892140SDag-Erling Smørgrav 	if(!inplace_cb_query_call(env, qinfo, flags, addr, addrlen, zone, zonelen,
2111bc892140SDag-Erling Smørgrav 		qstate, qstate->region))
2112bc892140SDag-Erling Smørgrav 			return NULL;
2113bc892140SDag-Erling Smørgrav 	serviced_gen_query(buff, qinfo->qname, qinfo->qname_len, qinfo->qtype,
2114bc892140SDag-Erling Smørgrav 		qinfo->qclass, flags);
2115bc892140SDag-Erling Smørgrav 	sq = lookup_serviced(outnet, buff, dnssec, addr, addrlen,
2116bc892140SDag-Erling Smørgrav 		qstate->edns_opts_back_out);
21178ed2b524SDag-Erling Smørgrav 	/* duplicate entries are included in the callback list, because
21188ed2b524SDag-Erling Smørgrav 	 * there is a counterpart registration by our caller that needs to
21198ed2b524SDag-Erling Smørgrav 	 * be doubly-removed (with callbacks perhaps). */
2120b7579f77SDag-Erling Smørgrav 	if(!(cb = (struct service_callback*)malloc(sizeof(*cb))))
2121b7579f77SDag-Erling Smørgrav 		return NULL;
2122b7579f77SDag-Erling Smørgrav 	if(!sq) {
2123b7579f77SDag-Erling Smørgrav 		/* make new serviced query entry */
2124ff825849SDag-Erling Smørgrav 		sq = serviced_create(outnet, buff, dnssec, want_dnssec, nocaps,
21250fb34990SDag-Erling Smørgrav 			tcp_upstream, ssl_upstream, tls_auth_name, addr,
21260fb34990SDag-Erling Smørgrav 			addrlen, zone, zonelen, (int)qinfo->qtype,
21270fb34990SDag-Erling Smørgrav 			qstate->edns_opts_back_out);
2128b7579f77SDag-Erling Smørgrav 		if(!sq) {
2129b7579f77SDag-Erling Smørgrav 			free(cb);
2130b7579f77SDag-Erling Smørgrav 			return NULL;
2131b7579f77SDag-Erling Smørgrav 		}
2132b7579f77SDag-Erling Smørgrav 		/* perform first network action */
2133b7579f77SDag-Erling Smørgrav 		if(outnet->do_udp && !(tcp_upstream || ssl_upstream)) {
2134b7579f77SDag-Erling Smørgrav 			if(!serviced_udp_send(sq, buff)) {
2135b7579f77SDag-Erling Smørgrav 				(void)rbtree_delete(outnet->serviced, sq);
2136b7579f77SDag-Erling Smørgrav 				free(sq->qbuf);
2137b7579f77SDag-Erling Smørgrav 				free(sq->zone);
2138b7579f77SDag-Erling Smørgrav 				free(sq);
2139b7579f77SDag-Erling Smørgrav 				free(cb);
2140b7579f77SDag-Erling Smørgrav 				return NULL;
2141b7579f77SDag-Erling Smørgrav 			}
2142b7579f77SDag-Erling Smørgrav 		} else {
2143b7579f77SDag-Erling Smørgrav 			if(!serviced_tcp_send(sq, buff)) {
2144b7579f77SDag-Erling Smørgrav 				(void)rbtree_delete(outnet->serviced, sq);
2145b7579f77SDag-Erling Smørgrav 				free(sq->qbuf);
2146b7579f77SDag-Erling Smørgrav 				free(sq->zone);
2147b7579f77SDag-Erling Smørgrav 				free(sq);
2148b7579f77SDag-Erling Smørgrav 				free(cb);
2149b7579f77SDag-Erling Smørgrav 				return NULL;
2150b7579f77SDag-Erling Smørgrav 			}
2151b7579f77SDag-Erling Smørgrav 		}
2152b7579f77SDag-Erling Smørgrav 	}
2153b7579f77SDag-Erling Smørgrav 	/* add callback to list of callbacks */
2154b7579f77SDag-Erling Smørgrav 	cb->cb = callback;
2155b7579f77SDag-Erling Smørgrav 	cb->cb_arg = callback_arg;
2156b7579f77SDag-Erling Smørgrav 	cb->next = sq->cblist;
2157b7579f77SDag-Erling Smørgrav 	sq->cblist = cb;
2158b7579f77SDag-Erling Smørgrav 	return sq;
2159b7579f77SDag-Erling Smørgrav }
2160b7579f77SDag-Erling Smørgrav 
2161b7579f77SDag-Erling Smørgrav /** remove callback from list */
2162b7579f77SDag-Erling Smørgrav static void
2163b7579f77SDag-Erling Smørgrav callback_list_remove(struct serviced_query* sq, void* cb_arg)
2164b7579f77SDag-Erling Smørgrav {
2165b7579f77SDag-Erling Smørgrav 	struct service_callback** pp = &sq->cblist;
2166b7579f77SDag-Erling Smørgrav 	while(*pp) {
2167b7579f77SDag-Erling Smørgrav 		if((*pp)->cb_arg == cb_arg) {
2168b7579f77SDag-Erling Smørgrav 			struct service_callback* del = *pp;
2169b7579f77SDag-Erling Smørgrav 			*pp = del->next;
2170b7579f77SDag-Erling Smørgrav 			free(del);
2171b7579f77SDag-Erling Smørgrav 			return;
2172b7579f77SDag-Erling Smørgrav 		}
2173b7579f77SDag-Erling Smørgrav 		pp = &(*pp)->next;
2174b7579f77SDag-Erling Smørgrav 	}
2175b7579f77SDag-Erling Smørgrav }
2176b7579f77SDag-Erling Smørgrav 
2177b7579f77SDag-Erling Smørgrav void outnet_serviced_query_stop(struct serviced_query* sq, void* cb_arg)
2178b7579f77SDag-Erling Smørgrav {
2179b7579f77SDag-Erling Smørgrav 	if(!sq)
2180b7579f77SDag-Erling Smørgrav 		return;
2181b7579f77SDag-Erling Smørgrav 	callback_list_remove(sq, cb_arg);
2182b7579f77SDag-Erling Smørgrav 	/* if callbacks() routine scheduled deletion, let it do that */
2183b7579f77SDag-Erling Smørgrav 	if(!sq->cblist && !sq->to_be_deleted) {
2184e2d15004SDag-Erling Smørgrav 		(void)rbtree_delete(sq->outnet->serviced, sq);
2185b7579f77SDag-Erling Smørgrav 		serviced_delete(sq);
2186b7579f77SDag-Erling Smørgrav 	}
2187b7579f77SDag-Erling Smørgrav }
2188b7579f77SDag-Erling Smørgrav 
218957bddd21SDag-Erling Smørgrav /** create fd to send to this destination */
219057bddd21SDag-Erling Smørgrav static int
219157bddd21SDag-Erling Smørgrav fd_for_dest(struct outside_network* outnet, struct sockaddr_storage* to_addr,
219257bddd21SDag-Erling Smørgrav 	socklen_t to_addrlen)
219357bddd21SDag-Erling Smørgrav {
219457bddd21SDag-Erling Smørgrav 	struct sockaddr_storage* addr;
219557bddd21SDag-Erling Smørgrav 	socklen_t addrlen;
2196*4c75e3aaSDag-Erling Smørgrav 	int i, try, pnum;
2197*4c75e3aaSDag-Erling Smørgrav 	struct port_if* pif;
2198*4c75e3aaSDag-Erling Smørgrav 
2199*4c75e3aaSDag-Erling Smørgrav 	/* create fd */
2200*4c75e3aaSDag-Erling Smørgrav 	for(try = 0; try<1000; try++) {
2201*4c75e3aaSDag-Erling Smørgrav 		int port = 0;
2202*4c75e3aaSDag-Erling Smørgrav 		int freebind = 0;
2203*4c75e3aaSDag-Erling Smørgrav 		int noproto = 0;
2204*4c75e3aaSDag-Erling Smørgrav 		int inuse = 0;
2205*4c75e3aaSDag-Erling Smørgrav 		int fd = -1;
220657bddd21SDag-Erling Smørgrav 
220757bddd21SDag-Erling Smørgrav 		/* select interface */
220857bddd21SDag-Erling Smørgrav 		if(addr_is_ip6(to_addr, to_addrlen)) {
220957bddd21SDag-Erling Smørgrav 			if(outnet->num_ip6 == 0) {
221057bddd21SDag-Erling Smørgrav 				char to[64];
221157bddd21SDag-Erling Smørgrav 				addr_to_str(to_addr, to_addrlen, to, sizeof(to));
221257bddd21SDag-Erling Smørgrav 				verbose(VERB_QUERY, "need ipv6 to send, but no ipv6 outgoing interfaces, for %s", to);
221357bddd21SDag-Erling Smørgrav 				return -1;
221457bddd21SDag-Erling Smørgrav 			}
221557bddd21SDag-Erling Smørgrav 			i = ub_random_max(outnet->rnd, outnet->num_ip6);
2216*4c75e3aaSDag-Erling Smørgrav 			pif = &outnet->ip6_ifs[i];
221757bddd21SDag-Erling Smørgrav 		} else {
221857bddd21SDag-Erling Smørgrav 			if(outnet->num_ip4 == 0) {
221957bddd21SDag-Erling Smørgrav 				char to[64];
222057bddd21SDag-Erling Smørgrav 				addr_to_str(to_addr, to_addrlen, to, sizeof(to));
222157bddd21SDag-Erling Smørgrav 				verbose(VERB_QUERY, "need ipv4 to send, but no ipv4 outgoing interfaces, for %s", to);
222257bddd21SDag-Erling Smørgrav 				return -1;
222357bddd21SDag-Erling Smørgrav 			}
222457bddd21SDag-Erling Smørgrav 			i = ub_random_max(outnet->rnd, outnet->num_ip4);
2225*4c75e3aaSDag-Erling Smørgrav 			pif = &outnet->ip4_ifs[i];
2226*4c75e3aaSDag-Erling Smørgrav 		}
2227*4c75e3aaSDag-Erling Smørgrav 		addr = &pif->addr;
2228*4c75e3aaSDag-Erling Smørgrav 		addrlen = pif->addrlen;
2229*4c75e3aaSDag-Erling Smørgrav 		pnum = ub_random_max(outnet->rnd, pif->avail_total);
2230*4c75e3aaSDag-Erling Smørgrav 		if(pnum < pif->inuse) {
2231*4c75e3aaSDag-Erling Smørgrav 			/* port already open */
2232*4c75e3aaSDag-Erling Smørgrav 			port = pif->out[pnum]->number;
2233*4c75e3aaSDag-Erling Smørgrav 		} else {
2234*4c75e3aaSDag-Erling Smørgrav 			/* unused ports in start part of array */
2235*4c75e3aaSDag-Erling Smørgrav 			port = pif->avail_ports[pnum - pif->inuse];
223657bddd21SDag-Erling Smørgrav 		}
223757bddd21SDag-Erling Smørgrav 
223857bddd21SDag-Erling Smørgrav 		if(addr_is_ip6(to_addr, to_addrlen)) {
223957bddd21SDag-Erling Smørgrav 			struct sockaddr_in6 sa = *(struct sockaddr_in6*)addr;
224057bddd21SDag-Erling Smørgrav 			sa.sin6_port = (in_port_t)htons((uint16_t)port);
224157bddd21SDag-Erling Smørgrav 			fd = create_udp_sock(AF_INET6, SOCK_DGRAM,
224257bddd21SDag-Erling Smørgrav 				(struct sockaddr*)&sa, addrlen, 1, &inuse, &noproto,
224357bddd21SDag-Erling Smørgrav 				0, 0, 0, NULL, 0, freebind, 0);
224457bddd21SDag-Erling Smørgrav 		} else {
224557bddd21SDag-Erling Smørgrav 			struct sockaddr_in* sa = (struct sockaddr_in*)addr;
224657bddd21SDag-Erling Smørgrav 			sa->sin_port = (in_port_t)htons((uint16_t)port);
224757bddd21SDag-Erling Smørgrav 			fd = create_udp_sock(AF_INET, SOCK_DGRAM,
224857bddd21SDag-Erling Smørgrav 				(struct sockaddr*)addr, addrlen, 1, &inuse, &noproto,
224957bddd21SDag-Erling Smørgrav 				0, 0, 0, NULL, 0, freebind, 0);
225057bddd21SDag-Erling Smørgrav 		}
225157bddd21SDag-Erling Smørgrav 		if(fd != -1) {
225257bddd21SDag-Erling Smørgrav 			return fd;
225357bddd21SDag-Erling Smørgrav 		}
225457bddd21SDag-Erling Smørgrav 		if(!inuse) {
225557bddd21SDag-Erling Smørgrav 			return -1;
225657bddd21SDag-Erling Smørgrav 		}
225757bddd21SDag-Erling Smørgrav 	}
225857bddd21SDag-Erling Smørgrav 	/* too many tries */
225957bddd21SDag-Erling Smørgrav 	log_err("cannot send probe, ports are in use");
226057bddd21SDag-Erling Smørgrav 	return -1;
226157bddd21SDag-Erling Smørgrav }
226257bddd21SDag-Erling Smørgrav 
226357bddd21SDag-Erling Smørgrav struct comm_point*
226457bddd21SDag-Erling Smørgrav outnet_comm_point_for_udp(struct outside_network* outnet,
226557bddd21SDag-Erling Smørgrav 	comm_point_callback_type* cb, void* cb_arg,
226657bddd21SDag-Erling Smørgrav 	struct sockaddr_storage* to_addr, socklen_t to_addrlen)
226757bddd21SDag-Erling Smørgrav {
226857bddd21SDag-Erling Smørgrav 	struct comm_point* cp;
226957bddd21SDag-Erling Smørgrav 	int fd = fd_for_dest(outnet, to_addr, to_addrlen);
227057bddd21SDag-Erling Smørgrav 	if(fd == -1) {
227157bddd21SDag-Erling Smørgrav 		return NULL;
227257bddd21SDag-Erling Smørgrav 	}
227357bddd21SDag-Erling Smørgrav 	cp = comm_point_create_udp(outnet->base, fd, outnet->udp_buff,
227457bddd21SDag-Erling Smørgrav 		cb, cb_arg);
227557bddd21SDag-Erling Smørgrav 	if(!cp) {
227657bddd21SDag-Erling Smørgrav 		log_err("malloc failure");
227757bddd21SDag-Erling Smørgrav 		close(fd);
227857bddd21SDag-Erling Smørgrav 		return NULL;
227957bddd21SDag-Erling Smørgrav 	}
228057bddd21SDag-Erling Smørgrav 	return cp;
228157bddd21SDag-Erling Smørgrav }
228257bddd21SDag-Erling Smørgrav 
228357bddd21SDag-Erling Smørgrav struct comm_point*
228457bddd21SDag-Erling Smørgrav outnet_comm_point_for_tcp(struct outside_network* outnet,
228557bddd21SDag-Erling Smørgrav 	comm_point_callback_type* cb, void* cb_arg,
228657bddd21SDag-Erling Smørgrav 	struct sockaddr_storage* to_addr, socklen_t to_addrlen,
228757bddd21SDag-Erling Smørgrav 	sldns_buffer* query, int timeout)
228857bddd21SDag-Erling Smørgrav {
228957bddd21SDag-Erling Smørgrav 	struct comm_point* cp;
229057bddd21SDag-Erling Smørgrav 	int fd = outnet_get_tcp_fd(to_addr, to_addrlen, outnet->tcp_mss);
229157bddd21SDag-Erling Smørgrav 	if(fd == -1) {
229257bddd21SDag-Erling Smørgrav 		return 0;
229357bddd21SDag-Erling Smørgrav 	}
229457bddd21SDag-Erling Smørgrav 	fd_set_nonblock(fd);
229557bddd21SDag-Erling Smørgrav 	if(!outnet_tcp_connect(fd, to_addr, to_addrlen)) {
229657bddd21SDag-Erling Smørgrav 		/* outnet_tcp_connect has closed fd on error for us */
229757bddd21SDag-Erling Smørgrav 		return 0;
229857bddd21SDag-Erling Smørgrav 	}
229957bddd21SDag-Erling Smørgrav 	cp = comm_point_create_tcp_out(outnet->base, 65552, cb, cb_arg);
230057bddd21SDag-Erling Smørgrav 	if(!cp) {
230157bddd21SDag-Erling Smørgrav 		log_err("malloc failure");
230257bddd21SDag-Erling Smørgrav 		close(fd);
230357bddd21SDag-Erling Smørgrav 		return 0;
230457bddd21SDag-Erling Smørgrav 	}
230557bddd21SDag-Erling Smørgrav 	cp->repinfo.addrlen = to_addrlen;
230657bddd21SDag-Erling Smørgrav 	memcpy(&cp->repinfo.addr, to_addr, to_addrlen);
230757bddd21SDag-Erling Smørgrav 	/* set timeout on TCP connection */
230857bddd21SDag-Erling Smørgrav 	comm_point_start_listening(cp, fd, timeout);
230957bddd21SDag-Erling Smørgrav 	/* copy scratch buffer to cp->buffer */
231057bddd21SDag-Erling Smørgrav 	sldns_buffer_copy(cp->buffer, query);
231157bddd21SDag-Erling Smørgrav 	return cp;
231257bddd21SDag-Erling Smørgrav }
231357bddd21SDag-Erling Smørgrav 
231457bddd21SDag-Erling Smørgrav /** setup http request headers in buffer for sending query to destination */
231557bddd21SDag-Erling Smørgrav static int
231657bddd21SDag-Erling Smørgrav setup_http_request(sldns_buffer* buf, char* host, char* path)
231757bddd21SDag-Erling Smørgrav {
231857bddd21SDag-Erling Smørgrav 	sldns_buffer_clear(buf);
231957bddd21SDag-Erling Smørgrav 	sldns_buffer_printf(buf, "GET /%s HTTP/1.1\r\n", path);
232057bddd21SDag-Erling Smørgrav 	sldns_buffer_printf(buf, "Host: %s\r\n", host);
232157bddd21SDag-Erling Smørgrav 	sldns_buffer_printf(buf, "User-Agent: unbound/%s\r\n",
232257bddd21SDag-Erling Smørgrav 		PACKAGE_VERSION);
232357bddd21SDag-Erling Smørgrav 	/* We do not really do multiple queries per connection,
232457bddd21SDag-Erling Smørgrav 	 * but this header setting is also not needed.
232557bddd21SDag-Erling Smørgrav 	 * sldns_buffer_printf(buf, "Connection: close\r\n") */
232657bddd21SDag-Erling Smørgrav 	sldns_buffer_printf(buf, "\r\n");
232757bddd21SDag-Erling Smørgrav 	if(sldns_buffer_position(buf)+10 > sldns_buffer_capacity(buf))
232857bddd21SDag-Erling Smørgrav 		return 0; /* somehow buffer too short, but it is about 60K
232957bddd21SDag-Erling Smørgrav 		and the request is only a couple bytes long. */
233057bddd21SDag-Erling Smørgrav 	sldns_buffer_flip(buf);
233157bddd21SDag-Erling Smørgrav 	return 1;
233257bddd21SDag-Erling Smørgrav }
233357bddd21SDag-Erling Smørgrav 
233457bddd21SDag-Erling Smørgrav struct comm_point*
233557bddd21SDag-Erling Smørgrav outnet_comm_point_for_http(struct outside_network* outnet,
233657bddd21SDag-Erling Smørgrav 	comm_point_callback_type* cb, void* cb_arg,
233757bddd21SDag-Erling Smørgrav 	struct sockaddr_storage* to_addr, socklen_t to_addrlen, int timeout,
233857bddd21SDag-Erling Smørgrav 	int ssl, char* host, char* path)
233957bddd21SDag-Erling Smørgrav {
234057bddd21SDag-Erling Smørgrav 	/* cp calls cb with err=NETEVENT_DONE when transfer is done */
234157bddd21SDag-Erling Smørgrav 	struct comm_point* cp;
234257bddd21SDag-Erling Smørgrav 	int fd = outnet_get_tcp_fd(to_addr, to_addrlen, outnet->tcp_mss);
234357bddd21SDag-Erling Smørgrav 	if(fd == -1) {
234457bddd21SDag-Erling Smørgrav 		return 0;
234557bddd21SDag-Erling Smørgrav 	}
234657bddd21SDag-Erling Smørgrav 	fd_set_nonblock(fd);
234757bddd21SDag-Erling Smørgrav 	if(!outnet_tcp_connect(fd, to_addr, to_addrlen)) {
234857bddd21SDag-Erling Smørgrav 		/* outnet_tcp_connect has closed fd on error for us */
234957bddd21SDag-Erling Smørgrav 		return 0;
235057bddd21SDag-Erling Smørgrav 	}
235157bddd21SDag-Erling Smørgrav 	cp = comm_point_create_http_out(outnet->base, 65552, cb, cb_arg,
235257bddd21SDag-Erling Smørgrav 		outnet->udp_buff);
235357bddd21SDag-Erling Smørgrav 	if(!cp) {
235457bddd21SDag-Erling Smørgrav 		log_err("malloc failure");
235557bddd21SDag-Erling Smørgrav 		close(fd);
235657bddd21SDag-Erling Smørgrav 		return 0;
235757bddd21SDag-Erling Smørgrav 	}
235857bddd21SDag-Erling Smørgrav 	cp->repinfo.addrlen = to_addrlen;
235957bddd21SDag-Erling Smørgrav 	memcpy(&cp->repinfo.addr, to_addr, to_addrlen);
236057bddd21SDag-Erling Smørgrav 
236157bddd21SDag-Erling Smørgrav 	/* setup for SSL (if needed) */
236257bddd21SDag-Erling Smørgrav 	if(ssl) {
236357bddd21SDag-Erling Smørgrav 		cp->ssl = outgoing_ssl_fd(outnet->sslctx, fd);
236457bddd21SDag-Erling Smørgrav 		if(!cp->ssl) {
236557bddd21SDag-Erling Smørgrav 			log_err("cannot setup https");
236657bddd21SDag-Erling Smørgrav 			comm_point_delete(cp);
236757bddd21SDag-Erling Smørgrav 			return NULL;
236857bddd21SDag-Erling Smørgrav 		}
236957bddd21SDag-Erling Smørgrav #ifdef USE_WINSOCK
237057bddd21SDag-Erling Smørgrav 		comm_point_tcp_win_bio_cb(cp, cp->ssl);
237157bddd21SDag-Erling Smørgrav #endif
237257bddd21SDag-Erling Smørgrav 		cp->ssl_shake_state = comm_ssl_shake_write;
237357bddd21SDag-Erling Smørgrav 		/* https verification */
237457bddd21SDag-Erling Smørgrav #ifdef HAVE_SSL_SET1_HOST
237557bddd21SDag-Erling Smørgrav 		if((SSL_CTX_get_verify_mode(outnet->sslctx)&SSL_VERIFY_PEER)) {
237657bddd21SDag-Erling Smørgrav 			/* because we set SSL_VERIFY_PEER, in netevent in
237757bddd21SDag-Erling Smørgrav 			 * ssl_handshake, it'll check if the certificate
237857bddd21SDag-Erling Smørgrav 			 * verification has succeeded */
237957bddd21SDag-Erling Smørgrav 			/* SSL_VERIFY_PEER is set on the sslctx */
238057bddd21SDag-Erling Smørgrav 			/* and the certificates to verify with are loaded into
238157bddd21SDag-Erling Smørgrav 			 * it with SSL_load_verify_locations or
238257bddd21SDag-Erling Smørgrav 			 * SSL_CTX_set_default_verify_paths */
238357bddd21SDag-Erling Smørgrav 			/* setting the hostname makes openssl verify the
238457bddd21SDag-Erling Smørgrav 			 * host name in the x509 certificate in the
238557bddd21SDag-Erling Smørgrav 			 * SSL connection*/
238657bddd21SDag-Erling Smørgrav 		 	if(!SSL_set1_host(cp->ssl, host)) {
238757bddd21SDag-Erling Smørgrav 				log_err("SSL_set1_host failed");
238857bddd21SDag-Erling Smørgrav 				comm_point_delete(cp);
238957bddd21SDag-Erling Smørgrav 				return NULL;
239057bddd21SDag-Erling Smørgrav 			}
239157bddd21SDag-Erling Smørgrav 		}
239257bddd21SDag-Erling Smørgrav #endif /* HAVE_SSL_SET1_HOST */
239357bddd21SDag-Erling Smørgrav 	}
239457bddd21SDag-Erling Smørgrav 
239557bddd21SDag-Erling Smørgrav 	/* set timeout on TCP connection */
239657bddd21SDag-Erling Smørgrav 	comm_point_start_listening(cp, fd, timeout);
239757bddd21SDag-Erling Smørgrav 
239857bddd21SDag-Erling Smørgrav 	/* setup http request in cp->buffer */
239957bddd21SDag-Erling Smørgrav 	if(!setup_http_request(cp->buffer, host, path)) {
240057bddd21SDag-Erling Smørgrav 		log_err("error setting up http request");
240157bddd21SDag-Erling Smørgrav 		comm_point_delete(cp);
240257bddd21SDag-Erling Smørgrav 		return NULL;
240357bddd21SDag-Erling Smørgrav 	}
240457bddd21SDag-Erling Smørgrav 	return cp;
240557bddd21SDag-Erling Smørgrav }
240657bddd21SDag-Erling Smørgrav 
2407b7579f77SDag-Erling Smørgrav /** get memory used by waiting tcp entry (in use or not) */
2408b7579f77SDag-Erling Smørgrav static size_t
2409b7579f77SDag-Erling Smørgrav waiting_tcp_get_mem(struct waiting_tcp* w)
2410b7579f77SDag-Erling Smørgrav {
2411b7579f77SDag-Erling Smørgrav 	size_t s;
2412b7579f77SDag-Erling Smørgrav 	if(!w) return 0;
2413b7579f77SDag-Erling Smørgrav 	s = sizeof(*w) + w->pkt_len;
2414b7579f77SDag-Erling Smørgrav 	if(w->timer)
2415b7579f77SDag-Erling Smørgrav 		s += comm_timer_get_mem(w->timer);
2416b7579f77SDag-Erling Smørgrav 	return s;
2417b7579f77SDag-Erling Smørgrav }
2418b7579f77SDag-Erling Smørgrav 
2419b7579f77SDag-Erling Smørgrav /** get memory used by port if */
2420b7579f77SDag-Erling Smørgrav static size_t
2421b7579f77SDag-Erling Smørgrav if_get_mem(struct port_if* pif)
2422b7579f77SDag-Erling Smørgrav {
2423b7579f77SDag-Erling Smørgrav 	size_t s;
2424b7579f77SDag-Erling Smørgrav 	int i;
2425b7579f77SDag-Erling Smørgrav 	s = sizeof(*pif) + sizeof(int)*pif->avail_total +
2426b7579f77SDag-Erling Smørgrav 		sizeof(struct port_comm*)*pif->maxout;
2427b7579f77SDag-Erling Smørgrav 	for(i=0; i<pif->inuse; i++)
2428b7579f77SDag-Erling Smørgrav 		s += sizeof(*pif->out[i]) +
2429b7579f77SDag-Erling Smørgrav 			comm_point_get_mem(pif->out[i]->cp);
2430b7579f77SDag-Erling Smørgrav 	return s;
2431b7579f77SDag-Erling Smørgrav }
2432b7579f77SDag-Erling Smørgrav 
2433b7579f77SDag-Erling Smørgrav /** get memory used by waiting udp */
2434b7579f77SDag-Erling Smørgrav static size_t
2435b7579f77SDag-Erling Smørgrav waiting_udp_get_mem(struct pending* w)
2436b7579f77SDag-Erling Smørgrav {
2437b7579f77SDag-Erling Smørgrav 	size_t s;
2438b7579f77SDag-Erling Smørgrav 	s = sizeof(*w) + comm_timer_get_mem(w->timer) + w->pkt_len;
2439b7579f77SDag-Erling Smørgrav 	return s;
2440b7579f77SDag-Erling Smørgrav }
2441b7579f77SDag-Erling Smørgrav 
2442b7579f77SDag-Erling Smørgrav size_t outnet_get_mem(struct outside_network* outnet)
2443b7579f77SDag-Erling Smørgrav {
2444b7579f77SDag-Erling Smørgrav 	size_t i;
2445b7579f77SDag-Erling Smørgrav 	int k;
2446b7579f77SDag-Erling Smørgrav 	struct waiting_tcp* w;
2447b7579f77SDag-Erling Smørgrav 	struct pending* u;
2448b7579f77SDag-Erling Smørgrav 	struct serviced_query* sq;
2449b7579f77SDag-Erling Smørgrav 	struct service_callback* sb;
2450b7579f77SDag-Erling Smørgrav 	struct port_comm* pc;
2451b7579f77SDag-Erling Smørgrav 	size_t s = sizeof(*outnet) + sizeof(*outnet->base) +
2452b7579f77SDag-Erling Smørgrav 		sizeof(*outnet->udp_buff) +
245317d15b25SDag-Erling Smørgrav 		sldns_buffer_capacity(outnet->udp_buff);
2454b7579f77SDag-Erling Smørgrav 	/* second buffer is not ours */
2455b7579f77SDag-Erling Smørgrav 	for(pc = outnet->unused_fds; pc; pc = pc->next) {
2456b7579f77SDag-Erling Smørgrav 		s += sizeof(*pc) + comm_point_get_mem(pc->cp);
2457b7579f77SDag-Erling Smørgrav 	}
2458b7579f77SDag-Erling Smørgrav 	for(k=0; k<outnet->num_ip4; k++)
2459b7579f77SDag-Erling Smørgrav 		s += if_get_mem(&outnet->ip4_ifs[k]);
2460b7579f77SDag-Erling Smørgrav 	for(k=0; k<outnet->num_ip6; k++)
2461b7579f77SDag-Erling Smørgrav 		s += if_get_mem(&outnet->ip6_ifs[k]);
2462b7579f77SDag-Erling Smørgrav 	for(u=outnet->udp_wait_first; u; u=u->next_waiting)
2463b7579f77SDag-Erling Smørgrav 		s += waiting_udp_get_mem(u);
2464b7579f77SDag-Erling Smørgrav 
2465b7579f77SDag-Erling Smørgrav 	s += sizeof(struct pending_tcp*)*outnet->num_tcp;
2466b7579f77SDag-Erling Smørgrav 	for(i=0; i<outnet->num_tcp; i++) {
2467b7579f77SDag-Erling Smørgrav 		s += sizeof(struct pending_tcp);
2468b7579f77SDag-Erling Smørgrav 		s += comm_point_get_mem(outnet->tcp_conns[i]->c);
2469b7579f77SDag-Erling Smørgrav 		if(outnet->tcp_conns[i]->query)
2470b7579f77SDag-Erling Smørgrav 			s += waiting_tcp_get_mem(outnet->tcp_conns[i]->query);
2471b7579f77SDag-Erling Smørgrav 	}
2472b7579f77SDag-Erling Smørgrav 	for(w=outnet->tcp_wait_first; w; w = w->next_waiting)
2473b7579f77SDag-Erling Smørgrav 		s += waiting_tcp_get_mem(w);
2474b7579f77SDag-Erling Smørgrav 	s += sizeof(*outnet->pending);
2475b7579f77SDag-Erling Smørgrav 	s += (sizeof(struct pending) + comm_timer_get_mem(NULL)) *
2476b7579f77SDag-Erling Smørgrav 		outnet->pending->count;
2477b7579f77SDag-Erling Smørgrav 	s += sizeof(*outnet->serviced);
2478b7579f77SDag-Erling Smørgrav 	s += outnet->svcd_overhead;
2479b7579f77SDag-Erling Smørgrav 	RBTREE_FOR(sq, struct serviced_query*, outnet->serviced) {
2480b7579f77SDag-Erling Smørgrav 		s += sizeof(*sq) + sq->qbuflen;
2481b7579f77SDag-Erling Smørgrav 		for(sb = sq->cblist; sb; sb = sb->next)
2482b7579f77SDag-Erling Smørgrav 			s += sizeof(*sb);
2483b7579f77SDag-Erling Smørgrav 	}
2484b7579f77SDag-Erling Smørgrav 	return s;
2485b7579f77SDag-Erling Smørgrav }
2486b7579f77SDag-Erling Smørgrav 
2487b7579f77SDag-Erling Smørgrav size_t
2488b7579f77SDag-Erling Smørgrav serviced_get_mem(struct serviced_query* sq)
2489b7579f77SDag-Erling Smørgrav {
2490b7579f77SDag-Erling Smørgrav 	struct service_callback* sb;
2491b7579f77SDag-Erling Smørgrav 	size_t s;
2492b7579f77SDag-Erling Smørgrav 	s = sizeof(*sq) + sq->qbuflen;
2493b7579f77SDag-Erling Smørgrav 	for(sb = sq->cblist; sb; sb = sb->next)
2494b7579f77SDag-Erling Smørgrav 		s += sizeof(*sb);
2495b7579f77SDag-Erling Smørgrav 	if(sq->status == serviced_query_UDP_EDNS ||
2496b7579f77SDag-Erling Smørgrav 		sq->status == serviced_query_UDP ||
2497b7579f77SDag-Erling Smørgrav 		sq->status == serviced_query_PROBE_EDNS ||
2498b7579f77SDag-Erling Smørgrav 		sq->status == serviced_query_UDP_EDNS_FRAG ||
2499b7579f77SDag-Erling Smørgrav 		sq->status == serviced_query_UDP_EDNS_fallback) {
2500b7579f77SDag-Erling Smørgrav 		s += sizeof(struct pending);
2501b7579f77SDag-Erling Smørgrav 		s += comm_timer_get_mem(NULL);
2502b7579f77SDag-Erling Smørgrav 	} else {
2503b7579f77SDag-Erling Smørgrav 		/* does not have size of the pkt pointer */
2504b7579f77SDag-Erling Smørgrav 		/* always has a timer except on malloc failures */
2505b7579f77SDag-Erling Smørgrav 
2506b7579f77SDag-Erling Smørgrav 		/* these sizes are part of the main outside network mem */
2507b7579f77SDag-Erling Smørgrav 		/*
2508b7579f77SDag-Erling Smørgrav 		s += sizeof(struct waiting_tcp);
2509b7579f77SDag-Erling Smørgrav 		s += comm_timer_get_mem(NULL);
2510b7579f77SDag-Erling Smørgrav 		*/
2511b7579f77SDag-Erling Smørgrav 	}
2512b7579f77SDag-Erling Smørgrav 	return s;
2513b7579f77SDag-Erling Smørgrav }
2514b7579f77SDag-Erling Smørgrav 
2515