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