1238106Sdes/* 2238106Sdes * services/outside_network.c - implement sending of queries and wait answer. 3238106Sdes * 4238106Sdes * Copyright (c) 2007, NLnet Labs. All rights reserved. 5238106Sdes * 6238106Sdes * This software is open source. 7238106Sdes * 8238106Sdes * Redistribution and use in source and binary forms, with or without 9238106Sdes * modification, are permitted provided that the following conditions 10238106Sdes * are met: 11238106Sdes * 12238106Sdes * Redistributions of source code must retain the above copyright notice, 13238106Sdes * this list of conditions and the following disclaimer. 14238106Sdes * 15238106Sdes * Redistributions in binary form must reproduce the above copyright notice, 16238106Sdes * this list of conditions and the following disclaimer in the documentation 17238106Sdes * and/or other materials provided with the distribution. 18238106Sdes * 19238106Sdes * Neither the name of the NLNET LABS nor the names of its contributors may 20238106Sdes * be used to endorse or promote products derived from this software without 21238106Sdes * specific prior written permission. 22238106Sdes * 23238106Sdes * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 24269257Sdes * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 25269257Sdes * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 26269257Sdes * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 27269257Sdes * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 28269257Sdes * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED 29269257Sdes * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 30269257Sdes * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 31269257Sdes * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 32269257Sdes * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 33269257Sdes * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 34238106Sdes */ 35238106Sdes 36238106Sdes/** 37238106Sdes * \file 38238106Sdes * 39238106Sdes * This file has functions to send queries to authoritative servers and 40238106Sdes * wait for the pending answer events. 41238106Sdes */ 42238106Sdes#include "config.h" 43238106Sdes#include <ctype.h> 44238106Sdes#ifdef HAVE_SYS_TYPES_H 45238106Sdes# include <sys/types.h> 46238106Sdes#endif 47238106Sdes#include <sys/time.h> 48238106Sdes#include "services/outside_network.h" 49238106Sdes#include "services/listen_dnsport.h" 50238106Sdes#include "services/cache/infra.h" 51238106Sdes#include "util/data/msgparse.h" 52238106Sdes#include "util/data/msgreply.h" 53238106Sdes#include "util/data/msgencode.h" 54238106Sdes#include "util/data/dname.h" 55238106Sdes#include "util/netevent.h" 56238106Sdes#include "util/log.h" 57238106Sdes#include "util/net_help.h" 58238106Sdes#include "util/random.h" 59238106Sdes#include "util/fptr_wlist.h" 60269257Sdes#include "ldns/sbuffer.h" 61249141Sdes#ifdef HAVE_OPENSSL_SSL_H 62238106Sdes#include <openssl/ssl.h> 63249141Sdes#endif 64238106Sdes 65238106Sdes#ifdef HAVE_NETDB_H 66238106Sdes#include <netdb.h> 67238106Sdes#endif 68238106Sdes#include <fcntl.h> 69238106Sdes 70238106Sdes/** number of times to retry making a random ID that is unique. */ 71238106Sdes#define MAX_ID_RETRY 1000 72238106Sdes/** number of times to retry finding interface, port that can be opened. */ 73238106Sdes#define MAX_PORT_RETRY 10000 74238106Sdes/** number of retries on outgoing UDP queries */ 75238106Sdes#define OUTBOUND_UDP_RETRY 1 76238106Sdes 77238106Sdes/** initiate TCP transaction for serviced query */ 78238106Sdesstatic void serviced_tcp_initiate(struct outside_network* outnet, 79269257Sdes struct serviced_query* sq, sldns_buffer* buff); 80238106Sdes/** with a fd available, randomize and send UDP */ 81238106Sdesstatic int randomize_and_send_udp(struct outside_network* outnet, 82269257Sdes struct pending* pend, sldns_buffer* packet, int timeout); 83238106Sdes 84238106Sdesint 85238106Sdespending_cmp(const void* key1, const void* key2) 86238106Sdes{ 87238106Sdes struct pending *p1 = (struct pending*)key1; 88238106Sdes struct pending *p2 = (struct pending*)key2; 89238106Sdes if(p1->id < p2->id) 90238106Sdes return -1; 91238106Sdes if(p1->id > p2->id) 92238106Sdes return 1; 93238106Sdes log_assert(p1->id == p2->id); 94238106Sdes return sockaddr_cmp(&p1->addr, p1->addrlen, &p2->addr, p2->addrlen); 95238106Sdes} 96238106Sdes 97238106Sdesint 98238106Sdesserviced_cmp(const void* key1, const void* key2) 99238106Sdes{ 100238106Sdes struct serviced_query* q1 = (struct serviced_query*)key1; 101238106Sdes struct serviced_query* q2 = (struct serviced_query*)key2; 102238106Sdes int r; 103238106Sdes if(q1->qbuflen < q2->qbuflen) 104238106Sdes return -1; 105238106Sdes if(q1->qbuflen > q2->qbuflen) 106238106Sdes return 1; 107238106Sdes log_assert(q1->qbuflen == q2->qbuflen); 108238106Sdes log_assert(q1->qbuflen >= 15 /* 10 header, root, type, class */); 109238106Sdes /* alternate casing of qname is still the same query */ 110238106Sdes if((r = memcmp(q1->qbuf, q2->qbuf, 10)) != 0) 111238106Sdes return r; 112238106Sdes if((r = memcmp(q1->qbuf+q1->qbuflen-4, q2->qbuf+q2->qbuflen-4, 4)) != 0) 113238106Sdes return r; 114238106Sdes if(q1->dnssec != q2->dnssec) { 115238106Sdes if(q1->dnssec < q2->dnssec) 116238106Sdes return -1; 117238106Sdes return 1; 118238106Sdes } 119238106Sdes if((r = query_dname_compare(q1->qbuf+10, q2->qbuf+10)) != 0) 120238106Sdes return r; 121238106Sdes return sockaddr_cmp(&q1->addr, q1->addrlen, &q2->addr, q2->addrlen); 122238106Sdes} 123238106Sdes 124238106Sdes/** delete waiting_tcp entry. Does not unlink from waiting list. 125238106Sdes * @param w: to delete. 126238106Sdes */ 127238106Sdesstatic void 128238106Sdeswaiting_tcp_delete(struct waiting_tcp* w) 129238106Sdes{ 130238106Sdes if(!w) return; 131238106Sdes if(w->timer) 132238106Sdes comm_timer_delete(w->timer); 133238106Sdes free(w); 134238106Sdes} 135238106Sdes 136238106Sdes/** 137238106Sdes * Pick random outgoing-interface of that family, and bind it. 138238106Sdes * port set to 0 so OS picks a port number for us. 139238106Sdes * if it is the ANY address, do not bind. 140238106Sdes * @param w: tcp structure with destination address. 141238106Sdes * @param s: socket fd. 142238106Sdes * @return false on error, socket closed. 143238106Sdes */ 144238106Sdesstatic int 145238106Sdespick_outgoing_tcp(struct waiting_tcp* w, int s) 146238106Sdes{ 147238106Sdes struct port_if* pi = NULL; 148238106Sdes int num; 149238106Sdes#ifdef INET6 150238106Sdes if(addr_is_ip6(&w->addr, w->addrlen)) 151238106Sdes num = w->outnet->num_ip6; 152238106Sdes else 153238106Sdes#endif 154238106Sdes num = w->outnet->num_ip4; 155238106Sdes if(num == 0) { 156238106Sdes log_err("no TCP outgoing interfaces of family"); 157238106Sdes log_addr(VERB_OPS, "for addr", &w->addr, w->addrlen); 158238106Sdes#ifndef USE_WINSOCK 159238106Sdes close(s); 160238106Sdes#else 161238106Sdes closesocket(s); 162238106Sdes#endif 163238106Sdes return 0; 164238106Sdes } 165238106Sdes#ifdef INET6 166238106Sdes if(addr_is_ip6(&w->addr, w->addrlen)) 167238106Sdes pi = &w->outnet->ip6_ifs[ub_random_max(w->outnet->rnd, num)]; 168238106Sdes else 169238106Sdes#endif 170238106Sdes pi = &w->outnet->ip4_ifs[ub_random_max(w->outnet->rnd, num)]; 171238106Sdes log_assert(pi); 172238106Sdes if(addr_is_any(&pi->addr, pi->addrlen)) { 173238106Sdes /* binding to the ANY interface is for listening sockets */ 174238106Sdes return 1; 175238106Sdes } 176238106Sdes /* set port to 0 */ 177238106Sdes if(addr_is_ip6(&pi->addr, pi->addrlen)) 178238106Sdes ((struct sockaddr_in6*)&pi->addr)->sin6_port = 0; 179238106Sdes else ((struct sockaddr_in*)&pi->addr)->sin_port = 0; 180238106Sdes if(bind(s, (struct sockaddr*)&pi->addr, pi->addrlen) != 0) { 181238106Sdes#ifndef USE_WINSOCK 182238106Sdes log_err("outgoing tcp: bind: %s", strerror(errno)); 183238106Sdes close(s); 184238106Sdes#else 185238106Sdes log_err("outgoing tcp: bind: %s", 186238106Sdes wsa_strerror(WSAGetLastError())); 187238106Sdes closesocket(s); 188238106Sdes#endif 189238106Sdes return 0; 190238106Sdes } 191238106Sdes log_addr(VERB_ALGO, "tcp bound to src", &pi->addr, pi->addrlen); 192238106Sdes return 1; 193238106Sdes} 194238106Sdes 195238106Sdes/** use next free buffer to service a tcp query */ 196238106Sdesstatic int 197238106Sdesoutnet_tcp_take_into_use(struct waiting_tcp* w, uint8_t* pkt, size_t pkt_len) 198238106Sdes{ 199238106Sdes struct pending_tcp* pend = w->outnet->tcp_free; 200238106Sdes int s; 201238106Sdes log_assert(pend); 202238106Sdes log_assert(pkt); 203238106Sdes log_assert(w->addrlen > 0); 204238106Sdes /* open socket */ 205238106Sdes#ifdef INET6 206238106Sdes if(addr_is_ip6(&w->addr, w->addrlen)) 207238106Sdes s = socket(PF_INET6, SOCK_STREAM, IPPROTO_TCP); 208238106Sdes else 209238106Sdes#endif 210238106Sdes s = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP); 211238106Sdes if(s == -1) { 212238106Sdes#ifndef USE_WINSOCK 213238106Sdes log_err("outgoing tcp: socket: %s", strerror(errno)); 214238106Sdes#else 215238106Sdes log_err("outgoing tcp: socket: %s", 216238106Sdes wsa_strerror(WSAGetLastError())); 217238106Sdes#endif 218238106Sdes log_addr(0, "failed address", &w->addr, w->addrlen); 219238106Sdes return 0; 220238106Sdes } 221238106Sdes if(!pick_outgoing_tcp(w, s)) 222238106Sdes return 0; 223238106Sdes 224238106Sdes fd_set_nonblock(s); 225238106Sdes if(connect(s, (struct sockaddr*)&w->addr, w->addrlen) == -1) { 226238106Sdes#ifndef USE_WINSOCK 227238106Sdes#ifdef EINPROGRESS 228238106Sdes if(errno != EINPROGRESS) { 229238106Sdes#else 230238106Sdes if(1) { 231238106Sdes#endif 232238106Sdes if(tcp_connect_errno_needs_log( 233238106Sdes (struct sockaddr*)&w->addr, w->addrlen)) 234238106Sdes log_err("outgoing tcp: connect: %s", 235238106Sdes strerror(errno)); 236238106Sdes close(s); 237238106Sdes#else /* USE_WINSOCK */ 238238106Sdes if(WSAGetLastError() != WSAEINPROGRESS && 239238106Sdes WSAGetLastError() != WSAEWOULDBLOCK) { 240238106Sdes closesocket(s); 241238106Sdes#endif 242238106Sdes log_addr(0, "failed address", &w->addr, w->addrlen); 243238106Sdes return 0; 244238106Sdes } 245238106Sdes } 246238106Sdes if(w->outnet->sslctx && w->ssl_upstream) { 247238106Sdes pend->c->ssl = outgoing_ssl_fd(w->outnet->sslctx, s); 248238106Sdes if(!pend->c->ssl) { 249238106Sdes pend->c->fd = s; 250238106Sdes comm_point_close(pend->c); 251238106Sdes return 0; 252238106Sdes } 253238106Sdes#ifdef USE_WINSOCK 254238106Sdes comm_point_tcp_win_bio_cb(pend->c, pend->c->ssl); 255238106Sdes#endif 256238106Sdes pend->c->ssl_shake_state = comm_ssl_shake_write; 257238106Sdes } 258238106Sdes w->pkt = NULL; 259238106Sdes w->next_waiting = (void*)pend; 260238106Sdes pend->id = LDNS_ID_WIRE(pkt); 261238106Sdes w->outnet->tcp_free = pend->next_free; 262238106Sdes pend->next_free = NULL; 263238106Sdes pend->query = w; 264238106Sdes pend->c->repinfo.addrlen = w->addrlen; 265238106Sdes memcpy(&pend->c->repinfo.addr, &w->addr, w->addrlen); 266269257Sdes sldns_buffer_clear(pend->c->buffer); 267269257Sdes sldns_buffer_write(pend->c->buffer, pkt, pkt_len); 268269257Sdes sldns_buffer_flip(pend->c->buffer); 269238106Sdes pend->c->tcp_is_reading = 0; 270238106Sdes pend->c->tcp_byte_count = 0; 271238106Sdes comm_point_start_listening(pend->c, s, -1); 272238106Sdes return 1; 273238106Sdes} 274238106Sdes 275238106Sdes/** see if buffers can be used to service TCP queries */ 276238106Sdesstatic void 277238106Sdesuse_free_buffer(struct outside_network* outnet) 278238106Sdes{ 279238106Sdes struct waiting_tcp* w; 280238106Sdes while(outnet->tcp_free && outnet->tcp_wait_first 281238106Sdes && !outnet->want_to_quit) { 282238106Sdes w = outnet->tcp_wait_first; 283238106Sdes outnet->tcp_wait_first = w->next_waiting; 284238106Sdes if(outnet->tcp_wait_last == w) 285238106Sdes outnet->tcp_wait_last = NULL; 286238106Sdes if(!outnet_tcp_take_into_use(w, w->pkt, w->pkt_len)) { 287238106Sdes comm_point_callback_t* cb = w->cb; 288238106Sdes void* cb_arg = w->cb_arg; 289238106Sdes waiting_tcp_delete(w); 290238106Sdes fptr_ok(fptr_whitelist_pending_tcp(cb)); 291238106Sdes (void)(*cb)(NULL, cb_arg, NETEVENT_CLOSED, NULL); 292238106Sdes } 293238106Sdes } 294238106Sdes} 295238106Sdes 296238106Sdes/** decomission a tcp buffer, closes commpoint and frees waiting_tcp entry */ 297238106Sdesstatic void 298238106Sdesdecomission_pending_tcp(struct outside_network* outnet, 299238106Sdes struct pending_tcp* pend) 300238106Sdes{ 301238106Sdes if(pend->c->ssl) { 302249141Sdes#ifdef HAVE_SSL 303238106Sdes SSL_shutdown(pend->c->ssl); 304238106Sdes SSL_free(pend->c->ssl); 305238106Sdes pend->c->ssl = NULL; 306249141Sdes#endif 307238106Sdes } 308238106Sdes comm_point_close(pend->c); 309238106Sdes pend->next_free = outnet->tcp_free; 310238106Sdes outnet->tcp_free = pend; 311238106Sdes waiting_tcp_delete(pend->query); 312238106Sdes pend->query = NULL; 313238106Sdes use_free_buffer(outnet); 314238106Sdes} 315238106Sdes 316238106Sdesint 317238106Sdesoutnet_tcp_cb(struct comm_point* c, void* arg, int error, 318238106Sdes struct comm_reply *reply_info) 319238106Sdes{ 320238106Sdes struct pending_tcp* pend = (struct pending_tcp*)arg; 321238106Sdes struct outside_network* outnet = pend->query->outnet; 322238106Sdes verbose(VERB_ALGO, "outnettcp cb"); 323238106Sdes if(error != NETEVENT_NOERROR) { 324238106Sdes verbose(VERB_QUERY, "outnettcp got tcp error %d", error); 325238106Sdes /* pass error below and exit */ 326238106Sdes } else { 327238106Sdes /* check ID */ 328269257Sdes if(sldns_buffer_limit(c->buffer) < sizeof(uint16_t) || 329269257Sdes LDNS_ID_WIRE(sldns_buffer_begin(c->buffer))!=pend->id) { 330238106Sdes log_addr(VERB_QUERY, 331238106Sdes "outnettcp: bad ID in reply, from:", 332238106Sdes &pend->query->addr, pend->query->addrlen); 333238106Sdes error = NETEVENT_CLOSED; 334238106Sdes } 335238106Sdes } 336238106Sdes fptr_ok(fptr_whitelist_pending_tcp(pend->query->cb)); 337238106Sdes (void)(*pend->query->cb)(c, pend->query->cb_arg, error, reply_info); 338238106Sdes decomission_pending_tcp(outnet, pend); 339238106Sdes return 0; 340238106Sdes} 341238106Sdes 342238106Sdes/** lower use count on pc, see if it can be closed */ 343238106Sdesstatic void 344238106Sdesportcomm_loweruse(struct outside_network* outnet, struct port_comm* pc) 345238106Sdes{ 346238106Sdes struct port_if* pif; 347238106Sdes pc->num_outstanding--; 348238106Sdes if(pc->num_outstanding > 0) { 349238106Sdes return; 350238106Sdes } 351238106Sdes /* close it and replace in unused list */ 352238106Sdes verbose(VERB_ALGO, "close of port %d", pc->number); 353238106Sdes comm_point_close(pc->cp); 354238106Sdes pif = pc->pif; 355238106Sdes log_assert(pif->inuse > 0); 356238106Sdes pif->avail_ports[pif->avail_total - pif->inuse] = pc->number; 357238106Sdes pif->inuse--; 358238106Sdes pif->out[pc->index] = pif->out[pif->inuse]; 359238106Sdes pif->out[pc->index]->index = pc->index; 360238106Sdes pc->next = outnet->unused_fds; 361238106Sdes outnet->unused_fds = pc; 362238106Sdes} 363238106Sdes 364238106Sdes/** try to send waiting UDP queries */ 365238106Sdesstatic void 366238106Sdesoutnet_send_wait_udp(struct outside_network* outnet) 367238106Sdes{ 368238106Sdes struct pending* pend; 369238106Sdes /* process waiting queries */ 370238106Sdes while(outnet->udp_wait_first && outnet->unused_fds 371238106Sdes && !outnet->want_to_quit) { 372238106Sdes pend = outnet->udp_wait_first; 373238106Sdes outnet->udp_wait_first = pend->next_waiting; 374238106Sdes if(!pend->next_waiting) outnet->udp_wait_last = NULL; 375269257Sdes sldns_buffer_clear(outnet->udp_buff); 376269257Sdes sldns_buffer_write(outnet->udp_buff, pend->pkt, pend->pkt_len); 377269257Sdes sldns_buffer_flip(outnet->udp_buff); 378238106Sdes free(pend->pkt); /* freeing now makes get_mem correct */ 379238106Sdes pend->pkt = NULL; 380238106Sdes pend->pkt_len = 0; 381238106Sdes if(!randomize_and_send_udp(outnet, pend, outnet->udp_buff, 382238106Sdes pend->timeout)) { 383238106Sdes /* callback error on pending */ 384269257Sdes if(pend->cb) { 385269257Sdes fptr_ok(fptr_whitelist_pending_udp(pend->cb)); 386269257Sdes (void)(*pend->cb)(outnet->unused_fds->cp, pend->cb_arg, 387269257Sdes NETEVENT_CLOSED, NULL); 388269257Sdes } 389238106Sdes pending_delete(outnet, pend); 390238106Sdes } 391238106Sdes } 392238106Sdes} 393238106Sdes 394238106Sdesint 395238106Sdesoutnet_udp_cb(struct comm_point* c, void* arg, int error, 396238106Sdes struct comm_reply *reply_info) 397238106Sdes{ 398238106Sdes struct outside_network* outnet = (struct outside_network*)arg; 399238106Sdes struct pending key; 400238106Sdes struct pending* p; 401238106Sdes verbose(VERB_ALGO, "answer cb"); 402238106Sdes 403238106Sdes if(error != NETEVENT_NOERROR) { 404238106Sdes verbose(VERB_QUERY, "outnetudp got udp error %d", error); 405238106Sdes return 0; 406238106Sdes } 407269257Sdes if(sldns_buffer_limit(c->buffer) < LDNS_HEADER_SIZE) { 408238106Sdes verbose(VERB_QUERY, "outnetudp udp too short"); 409238106Sdes return 0; 410238106Sdes } 411238106Sdes log_assert(reply_info); 412238106Sdes 413238106Sdes /* setup lookup key */ 414269257Sdes key.id = (unsigned)LDNS_ID_WIRE(sldns_buffer_begin(c->buffer)); 415238106Sdes memcpy(&key.addr, &reply_info->addr, reply_info->addrlen); 416238106Sdes key.addrlen = reply_info->addrlen; 417238106Sdes verbose(VERB_ALGO, "Incoming reply id = %4.4x", key.id); 418238106Sdes log_addr(VERB_ALGO, "Incoming reply addr =", 419238106Sdes &reply_info->addr, reply_info->addrlen); 420238106Sdes 421238106Sdes /* find it, see if this thing is a valid query response */ 422238106Sdes verbose(VERB_ALGO, "lookup size is %d entries", (int)outnet->pending->count); 423238106Sdes p = (struct pending*)rbtree_search(outnet->pending, &key); 424238106Sdes if(!p) { 425238106Sdes verbose(VERB_QUERY, "received unwanted or unsolicited udp reply dropped."); 426238106Sdes log_buf(VERB_ALGO, "dropped message", c->buffer); 427238106Sdes outnet->unwanted_replies++; 428238106Sdes if(outnet->unwanted_threshold && ++outnet->unwanted_total 429238106Sdes >= outnet->unwanted_threshold) { 430238106Sdes log_warn("unwanted reply total reached threshold (%u)" 431238106Sdes " you may be under attack." 432238106Sdes " defensive action: clearing the cache", 433238106Sdes (unsigned)outnet->unwanted_threshold); 434238106Sdes fptr_ok(fptr_whitelist_alloc_cleanup( 435238106Sdes outnet->unwanted_action)); 436238106Sdes (*outnet->unwanted_action)(outnet->unwanted_param); 437238106Sdes outnet->unwanted_total = 0; 438238106Sdes } 439238106Sdes return 0; 440238106Sdes } 441238106Sdes 442238106Sdes verbose(VERB_ALGO, "received udp reply."); 443238106Sdes log_buf(VERB_ALGO, "udp message", c->buffer); 444238106Sdes if(p->pc->cp != c) { 445238106Sdes verbose(VERB_QUERY, "received reply id,addr on wrong port. " 446238106Sdes "dropped."); 447238106Sdes outnet->unwanted_replies++; 448238106Sdes if(outnet->unwanted_threshold && ++outnet->unwanted_total 449238106Sdes >= outnet->unwanted_threshold) { 450238106Sdes log_warn("unwanted reply total reached threshold (%u)" 451238106Sdes " you may be under attack." 452238106Sdes " defensive action: clearing the cache", 453238106Sdes (unsigned)outnet->unwanted_threshold); 454238106Sdes fptr_ok(fptr_whitelist_alloc_cleanup( 455238106Sdes outnet->unwanted_action)); 456238106Sdes (*outnet->unwanted_action)(outnet->unwanted_param); 457238106Sdes outnet->unwanted_total = 0; 458238106Sdes } 459238106Sdes return 0; 460238106Sdes } 461238106Sdes comm_timer_disable(p->timer); 462238106Sdes verbose(VERB_ALGO, "outnet handle udp reply"); 463238106Sdes /* delete from tree first in case callback creates a retry */ 464238106Sdes (void)rbtree_delete(outnet->pending, p->node.key); 465269257Sdes if(p->cb) { 466269257Sdes fptr_ok(fptr_whitelist_pending_udp(p->cb)); 467269257Sdes (void)(*p->cb)(p->pc->cp, p->cb_arg, NETEVENT_NOERROR, reply_info); 468269257Sdes } 469238106Sdes portcomm_loweruse(outnet, p->pc); 470238106Sdes pending_delete(NULL, p); 471238106Sdes outnet_send_wait_udp(outnet); 472238106Sdes return 0; 473238106Sdes} 474238106Sdes 475238106Sdes/** calculate number of ip4 and ip6 interfaces*/ 476238106Sdesstatic void 477238106Sdescalc_num46(char** ifs, int num_ifs, int do_ip4, int do_ip6, 478238106Sdes int* num_ip4, int* num_ip6) 479238106Sdes{ 480238106Sdes int i; 481238106Sdes *num_ip4 = 0; 482238106Sdes *num_ip6 = 0; 483238106Sdes if(num_ifs <= 0) { 484238106Sdes if(do_ip4) 485238106Sdes *num_ip4 = 1; 486238106Sdes if(do_ip6) 487238106Sdes *num_ip6 = 1; 488238106Sdes return; 489238106Sdes } 490238106Sdes for(i=0; i<num_ifs; i++) 491238106Sdes { 492238106Sdes if(str_is_ip6(ifs[i])) { 493238106Sdes if(do_ip6) 494238106Sdes (*num_ip6)++; 495238106Sdes } else { 496238106Sdes if(do_ip4) 497238106Sdes (*num_ip4)++; 498238106Sdes } 499238106Sdes } 500238106Sdes 501238106Sdes} 502238106Sdes 503269257Sdesvoid 504269257Sdespending_udp_timer_delay_cb(void* arg) 505269257Sdes{ 506269257Sdes struct pending* p = (struct pending*)arg; 507269257Sdes struct outside_network* outnet = p->outnet; 508269257Sdes verbose(VERB_ALGO, "timeout udp with delay"); 509269257Sdes portcomm_loweruse(outnet, p->pc); 510269257Sdes pending_delete(outnet, p); 511269257Sdes outnet_send_wait_udp(outnet); 512269257Sdes} 513269257Sdes 514238106Sdesvoid 515238106Sdespending_udp_timer_cb(void *arg) 516238106Sdes{ 517238106Sdes struct pending* p = (struct pending*)arg; 518238106Sdes struct outside_network* outnet = p->outnet; 519238106Sdes /* it timed out */ 520238106Sdes verbose(VERB_ALGO, "timeout udp"); 521269257Sdes if(p->cb) { 522269257Sdes fptr_ok(fptr_whitelist_pending_udp(p->cb)); 523269257Sdes (void)(*p->cb)(p->pc->cp, p->cb_arg, NETEVENT_TIMEOUT, NULL); 524269257Sdes } 525269257Sdes /* if delayclose, keep port open for a longer time. 526269257Sdes * But if the udpwaitlist exists, then we are struggling to 527269257Sdes * keep up with demand for sockets, so do not wait, but service 528269257Sdes * the customer (customer service more important than portICMPs) */ 529269257Sdes if(outnet->delayclose && !outnet->udp_wait_first) { 530269257Sdes p->cb = NULL; 531269257Sdes p->timer->callback = &pending_udp_timer_delay_cb; 532269257Sdes comm_timer_set(p->timer, &outnet->delay_tv); 533269257Sdes return; 534269257Sdes } 535238106Sdes portcomm_loweruse(outnet, p->pc); 536238106Sdes pending_delete(outnet, p); 537238106Sdes outnet_send_wait_udp(outnet); 538238106Sdes} 539238106Sdes 540238106Sdes/** create pending_tcp buffers */ 541238106Sdesstatic int 542238106Sdescreate_pending_tcp(struct outside_network* outnet, size_t bufsize) 543238106Sdes{ 544238106Sdes size_t i; 545238106Sdes if(outnet->num_tcp == 0) 546238106Sdes return 1; /* no tcp needed, nothing to do */ 547238106Sdes if(!(outnet->tcp_conns = (struct pending_tcp **)calloc( 548238106Sdes outnet->num_tcp, sizeof(struct pending_tcp*)))) 549238106Sdes return 0; 550238106Sdes for(i=0; i<outnet->num_tcp; i++) { 551238106Sdes if(!(outnet->tcp_conns[i] = (struct pending_tcp*)calloc(1, 552238106Sdes sizeof(struct pending_tcp)))) 553238106Sdes return 0; 554238106Sdes outnet->tcp_conns[i]->next_free = outnet->tcp_free; 555238106Sdes outnet->tcp_free = outnet->tcp_conns[i]; 556238106Sdes outnet->tcp_conns[i]->c = comm_point_create_tcp_out( 557238106Sdes outnet->base, bufsize, outnet_tcp_cb, 558238106Sdes outnet->tcp_conns[i]); 559238106Sdes if(!outnet->tcp_conns[i]->c) 560238106Sdes return 0; 561238106Sdes } 562238106Sdes return 1; 563238106Sdes} 564238106Sdes 565238106Sdes/** setup an outgoing interface, ready address */ 566238106Sdesstatic int setup_if(struct port_if* pif, const char* addrstr, 567238106Sdes int* avail, int numavail, size_t numfd) 568238106Sdes{ 569238106Sdes pif->avail_total = numavail; 570238106Sdes pif->avail_ports = (int*)memdup(avail, (size_t)numavail*sizeof(int)); 571238106Sdes if(!pif->avail_ports) 572238106Sdes return 0; 573238106Sdes if(!ipstrtoaddr(addrstr, UNBOUND_DNS_PORT, &pif->addr, &pif->addrlen)) 574238106Sdes return 0; 575238106Sdes pif->maxout = (int)numfd; 576238106Sdes pif->inuse = 0; 577238106Sdes pif->out = (struct port_comm**)calloc(numfd, 578238106Sdes sizeof(struct port_comm*)); 579238106Sdes if(!pif->out) 580238106Sdes return 0; 581238106Sdes return 1; 582238106Sdes} 583238106Sdes 584238106Sdesstruct outside_network* 585238106Sdesoutside_network_create(struct comm_base *base, size_t bufsize, 586238106Sdes size_t num_ports, char** ifs, int num_ifs, int do_ip4, 587238106Sdes int do_ip6, size_t num_tcp, struct infra_cache* infra, 588238106Sdes struct ub_randstate* rnd, int use_caps_for_id, int* availports, 589238106Sdes int numavailports, size_t unwanted_threshold, 590238106Sdes void (*unwanted_action)(void*), void* unwanted_param, int do_udp, 591269257Sdes void* sslctx, int delayclose) 592238106Sdes{ 593238106Sdes struct outside_network* outnet = (struct outside_network*) 594238106Sdes calloc(1, sizeof(struct outside_network)); 595238106Sdes size_t k; 596238106Sdes if(!outnet) { 597238106Sdes log_err("malloc failed"); 598238106Sdes return NULL; 599238106Sdes } 600238106Sdes comm_base_timept(base, &outnet->now_secs, &outnet->now_tv); 601238106Sdes outnet->base = base; 602238106Sdes outnet->num_tcp = num_tcp; 603238106Sdes outnet->infra = infra; 604238106Sdes outnet->rnd = rnd; 605238106Sdes outnet->sslctx = sslctx; 606238106Sdes outnet->svcd_overhead = 0; 607238106Sdes outnet->want_to_quit = 0; 608238106Sdes outnet->unwanted_threshold = unwanted_threshold; 609238106Sdes outnet->unwanted_action = unwanted_action; 610238106Sdes outnet->unwanted_param = unwanted_param; 611238106Sdes outnet->use_caps_for_id = use_caps_for_id; 612238106Sdes outnet->do_udp = do_udp; 613269257Sdes#ifndef S_SPLINT_S 614269257Sdes if(delayclose) { 615269257Sdes outnet->delayclose = 1; 616269257Sdes outnet->delay_tv.tv_sec = delayclose/1000; 617269257Sdes outnet->delay_tv.tv_usec = (delayclose%1000)*1000; 618269257Sdes } 619269257Sdes#endif 620238106Sdes if(numavailports == 0) { 621238106Sdes log_err("no outgoing ports available"); 622238106Sdes outside_network_delete(outnet); 623238106Sdes return NULL; 624238106Sdes } 625238106Sdes#ifndef INET6 626238106Sdes do_ip6 = 0; 627238106Sdes#endif 628238106Sdes calc_num46(ifs, num_ifs, do_ip4, do_ip6, 629238106Sdes &outnet->num_ip4, &outnet->num_ip6); 630238106Sdes if(outnet->num_ip4 != 0) { 631238106Sdes if(!(outnet->ip4_ifs = (struct port_if*)calloc( 632238106Sdes (size_t)outnet->num_ip4, sizeof(struct port_if)))) { 633238106Sdes log_err("malloc failed"); 634238106Sdes outside_network_delete(outnet); 635238106Sdes return NULL; 636238106Sdes } 637238106Sdes } 638238106Sdes if(outnet->num_ip6 != 0) { 639238106Sdes if(!(outnet->ip6_ifs = (struct port_if*)calloc( 640238106Sdes (size_t)outnet->num_ip6, sizeof(struct port_if)))) { 641238106Sdes log_err("malloc failed"); 642238106Sdes outside_network_delete(outnet); 643238106Sdes return NULL; 644238106Sdes } 645238106Sdes } 646269257Sdes if( !(outnet->udp_buff = sldns_buffer_new(bufsize)) || 647238106Sdes !(outnet->pending = rbtree_create(pending_cmp)) || 648238106Sdes !(outnet->serviced = rbtree_create(serviced_cmp)) || 649238106Sdes !create_pending_tcp(outnet, bufsize)) { 650238106Sdes log_err("malloc failed"); 651238106Sdes outside_network_delete(outnet); 652238106Sdes return NULL; 653238106Sdes } 654238106Sdes 655238106Sdes /* allocate commpoints */ 656238106Sdes for(k=0; k<num_ports; k++) { 657238106Sdes struct port_comm* pc; 658238106Sdes pc = (struct port_comm*)calloc(1, sizeof(*pc)); 659238106Sdes if(!pc) { 660238106Sdes log_err("malloc failed"); 661238106Sdes outside_network_delete(outnet); 662238106Sdes return NULL; 663238106Sdes } 664238106Sdes pc->cp = comm_point_create_udp(outnet->base, -1, 665238106Sdes outnet->udp_buff, outnet_udp_cb, outnet); 666238106Sdes if(!pc->cp) { 667238106Sdes log_err("malloc failed"); 668238106Sdes free(pc); 669238106Sdes outside_network_delete(outnet); 670238106Sdes return NULL; 671238106Sdes } 672238106Sdes pc->next = outnet->unused_fds; 673238106Sdes outnet->unused_fds = pc; 674238106Sdes } 675238106Sdes 676238106Sdes /* allocate interfaces */ 677238106Sdes if(num_ifs == 0) { 678238106Sdes if(do_ip4 && !setup_if(&outnet->ip4_ifs[0], "0.0.0.0", 679238106Sdes availports, numavailports, num_ports)) { 680238106Sdes log_err("malloc failed"); 681238106Sdes outside_network_delete(outnet); 682238106Sdes return NULL; 683238106Sdes } 684238106Sdes if(do_ip6 && !setup_if(&outnet->ip6_ifs[0], "::", 685238106Sdes availports, numavailports, num_ports)) { 686238106Sdes log_err("malloc failed"); 687238106Sdes outside_network_delete(outnet); 688238106Sdes return NULL; 689238106Sdes } 690238106Sdes } else { 691238106Sdes size_t done_4 = 0, done_6 = 0; 692238106Sdes int i; 693238106Sdes for(i=0; i<num_ifs; i++) { 694238106Sdes if(str_is_ip6(ifs[i]) && do_ip6) { 695238106Sdes if(!setup_if(&outnet->ip6_ifs[done_6], ifs[i], 696238106Sdes availports, numavailports, num_ports)){ 697238106Sdes log_err("malloc failed"); 698238106Sdes outside_network_delete(outnet); 699238106Sdes return NULL; 700238106Sdes } 701238106Sdes done_6++; 702238106Sdes } 703238106Sdes if(!str_is_ip6(ifs[i]) && do_ip4) { 704238106Sdes if(!setup_if(&outnet->ip4_ifs[done_4], ifs[i], 705238106Sdes availports, numavailports, num_ports)){ 706238106Sdes log_err("malloc failed"); 707238106Sdes outside_network_delete(outnet); 708238106Sdes return NULL; 709238106Sdes } 710238106Sdes done_4++; 711238106Sdes } 712238106Sdes } 713238106Sdes } 714238106Sdes return outnet; 715238106Sdes} 716238106Sdes 717238106Sdes/** helper pending delete */ 718238106Sdesstatic void 719238106Sdespending_node_del(rbnode_t* node, void* arg) 720238106Sdes{ 721238106Sdes struct pending* pend = (struct pending*)node; 722238106Sdes struct outside_network* outnet = (struct outside_network*)arg; 723238106Sdes pending_delete(outnet, pend); 724238106Sdes} 725238106Sdes 726238106Sdes/** helper serviced delete */ 727238106Sdesstatic void 728238106Sdesserviced_node_del(rbnode_t* node, void* ATTR_UNUSED(arg)) 729238106Sdes{ 730238106Sdes struct serviced_query* sq = (struct serviced_query*)node; 731238106Sdes struct service_callback* p = sq->cblist, *np; 732238106Sdes free(sq->qbuf); 733238106Sdes free(sq->zone); 734238106Sdes while(p) { 735238106Sdes np = p->next; 736238106Sdes free(p); 737238106Sdes p = np; 738238106Sdes } 739238106Sdes free(sq); 740238106Sdes} 741238106Sdes 742238106Sdesvoid 743238106Sdesoutside_network_quit_prepare(struct outside_network* outnet) 744238106Sdes{ 745238106Sdes if(!outnet) 746238106Sdes return; 747238106Sdes /* prevent queued items from being sent */ 748238106Sdes outnet->want_to_quit = 1; 749238106Sdes} 750238106Sdes 751238106Sdesvoid 752238106Sdesoutside_network_delete(struct outside_network* outnet) 753238106Sdes{ 754238106Sdes if(!outnet) 755238106Sdes return; 756238106Sdes outnet->want_to_quit = 1; 757238106Sdes /* check every element, since we can be called on malloc error */ 758238106Sdes if(outnet->pending) { 759238106Sdes /* free pending elements, but do no unlink from tree. */ 760238106Sdes traverse_postorder(outnet->pending, pending_node_del, NULL); 761238106Sdes free(outnet->pending); 762238106Sdes } 763238106Sdes if(outnet->serviced) { 764238106Sdes traverse_postorder(outnet->serviced, serviced_node_del, NULL); 765238106Sdes free(outnet->serviced); 766238106Sdes } 767238106Sdes if(outnet->udp_buff) 768269257Sdes sldns_buffer_free(outnet->udp_buff); 769238106Sdes if(outnet->unused_fds) { 770238106Sdes struct port_comm* p = outnet->unused_fds, *np; 771238106Sdes while(p) { 772238106Sdes np = p->next; 773238106Sdes comm_point_delete(p->cp); 774238106Sdes free(p); 775238106Sdes p = np; 776238106Sdes } 777238106Sdes outnet->unused_fds = NULL; 778238106Sdes } 779238106Sdes if(outnet->ip4_ifs) { 780238106Sdes int i, k; 781238106Sdes for(i=0; i<outnet->num_ip4; i++) { 782238106Sdes for(k=0; k<outnet->ip4_ifs[i].inuse; k++) { 783238106Sdes struct port_comm* pc = outnet->ip4_ifs[i]. 784238106Sdes out[k]; 785238106Sdes comm_point_delete(pc->cp); 786238106Sdes free(pc); 787238106Sdes } 788238106Sdes free(outnet->ip4_ifs[i].avail_ports); 789238106Sdes free(outnet->ip4_ifs[i].out); 790238106Sdes } 791238106Sdes free(outnet->ip4_ifs); 792238106Sdes } 793238106Sdes if(outnet->ip6_ifs) { 794238106Sdes int i, k; 795238106Sdes for(i=0; i<outnet->num_ip6; i++) { 796238106Sdes for(k=0; k<outnet->ip6_ifs[i].inuse; k++) { 797238106Sdes struct port_comm* pc = outnet->ip6_ifs[i]. 798238106Sdes out[k]; 799238106Sdes comm_point_delete(pc->cp); 800238106Sdes free(pc); 801238106Sdes } 802238106Sdes free(outnet->ip6_ifs[i].avail_ports); 803238106Sdes free(outnet->ip6_ifs[i].out); 804238106Sdes } 805238106Sdes free(outnet->ip6_ifs); 806238106Sdes } 807238106Sdes if(outnet->tcp_conns) { 808238106Sdes size_t i; 809238106Sdes for(i=0; i<outnet->num_tcp; i++) 810238106Sdes if(outnet->tcp_conns[i]) { 811238106Sdes comm_point_delete(outnet->tcp_conns[i]->c); 812238106Sdes waiting_tcp_delete(outnet->tcp_conns[i]->query); 813238106Sdes free(outnet->tcp_conns[i]); 814238106Sdes } 815238106Sdes free(outnet->tcp_conns); 816238106Sdes } 817238106Sdes if(outnet->tcp_wait_first) { 818238106Sdes struct waiting_tcp* p = outnet->tcp_wait_first, *np; 819238106Sdes while(p) { 820238106Sdes np = p->next_waiting; 821238106Sdes waiting_tcp_delete(p); 822238106Sdes p = np; 823238106Sdes } 824238106Sdes } 825238106Sdes if(outnet->udp_wait_first) { 826238106Sdes struct pending* p = outnet->udp_wait_first, *np; 827238106Sdes while(p) { 828238106Sdes np = p->next_waiting; 829238106Sdes pending_delete(NULL, p); 830238106Sdes p = np; 831238106Sdes } 832238106Sdes } 833238106Sdes free(outnet); 834238106Sdes} 835238106Sdes 836238106Sdesvoid 837238106Sdespending_delete(struct outside_network* outnet, struct pending* p) 838238106Sdes{ 839238106Sdes if(!p) 840238106Sdes return; 841238106Sdes if(outnet && outnet->udp_wait_first && 842238106Sdes (p->next_waiting || p == outnet->udp_wait_last) ) { 843238106Sdes /* delete from waiting list, if it is in the waiting list */ 844238106Sdes struct pending* prev = NULL, *x = outnet->udp_wait_first; 845238106Sdes while(x && x != p) { 846238106Sdes prev = x; 847238106Sdes x = x->next_waiting; 848238106Sdes } 849238106Sdes if(x) { 850238106Sdes log_assert(x == p); 851238106Sdes if(prev) 852238106Sdes prev->next_waiting = p->next_waiting; 853238106Sdes else outnet->udp_wait_first = p->next_waiting; 854238106Sdes if(outnet->udp_wait_last == p) 855238106Sdes outnet->udp_wait_last = prev; 856238106Sdes } 857238106Sdes } 858238106Sdes if(outnet) { 859238106Sdes (void)rbtree_delete(outnet->pending, p->node.key); 860238106Sdes } 861238106Sdes if(p->timer) 862238106Sdes comm_timer_delete(p->timer); 863238106Sdes free(p->pkt); 864238106Sdes free(p); 865238106Sdes} 866238106Sdes 867238106Sdes/** 868238106Sdes * Try to open a UDP socket for outgoing communication. 869238106Sdes * Sets sockets options as needed. 870238106Sdes * @param addr: socket address. 871238106Sdes * @param addrlen: length of address. 872238106Sdes * @param port: port override for addr. 873238106Sdes * @param inuse: if -1 is returned, this bool means the port was in use. 874238106Sdes * @return fd or -1 875238106Sdes */ 876238106Sdesstatic int 877238106Sdesudp_sockport(struct sockaddr_storage* addr, socklen_t addrlen, int port, 878238106Sdes int* inuse) 879238106Sdes{ 880238106Sdes int fd, noproto; 881238106Sdes if(addr_is_ip6(addr, addrlen)) { 882238106Sdes struct sockaddr_in6* sa = (struct sockaddr_in6*)addr; 883238106Sdes sa->sin6_port = (in_port_t)htons((uint16_t)port); 884238106Sdes fd = create_udp_sock(AF_INET6, SOCK_DGRAM, 885238106Sdes (struct sockaddr*)addr, addrlen, 1, inuse, &noproto, 886269257Sdes 0, 0, 0, NULL); 887238106Sdes } else { 888238106Sdes struct sockaddr_in* sa = (struct sockaddr_in*)addr; 889238106Sdes sa->sin_port = (in_port_t)htons((uint16_t)port); 890238106Sdes fd = create_udp_sock(AF_INET, SOCK_DGRAM, 891238106Sdes (struct sockaddr*)addr, addrlen, 1, inuse, &noproto, 892269257Sdes 0, 0, 0, NULL); 893238106Sdes } 894238106Sdes return fd; 895238106Sdes} 896238106Sdes 897238106Sdes/** Select random ID */ 898238106Sdesstatic int 899238106Sdesselect_id(struct outside_network* outnet, struct pending* pend, 900269257Sdes sldns_buffer* packet) 901238106Sdes{ 902238106Sdes int id_tries = 0; 903238106Sdes pend->id = ((unsigned)ub_random(outnet->rnd)>>8) & 0xffff; 904269257Sdes LDNS_ID_SET(sldns_buffer_begin(packet), pend->id); 905238106Sdes 906238106Sdes /* insert in tree */ 907238106Sdes pend->node.key = pend; 908238106Sdes while(!rbtree_insert(outnet->pending, &pend->node)) { 909238106Sdes /* change ID to avoid collision */ 910238106Sdes pend->id = ((unsigned)ub_random(outnet->rnd)>>8) & 0xffff; 911269257Sdes LDNS_ID_SET(sldns_buffer_begin(packet), pend->id); 912238106Sdes id_tries++; 913238106Sdes if(id_tries == MAX_ID_RETRY) { 914238106Sdes pend->id=99999; /* non existant ID */ 915238106Sdes log_err("failed to generate unique ID, drop msg"); 916238106Sdes return 0; 917238106Sdes } 918238106Sdes } 919238106Sdes verbose(VERB_ALGO, "inserted new pending reply id=%4.4x", pend->id); 920238106Sdes return 1; 921238106Sdes} 922238106Sdes 923238106Sdes/** Select random interface and port */ 924238106Sdesstatic int 925238106Sdesselect_ifport(struct outside_network* outnet, struct pending* pend, 926238106Sdes int num_if, struct port_if* ifs) 927238106Sdes{ 928238106Sdes int my_if, my_port, fd, portno, inuse, tries=0; 929238106Sdes struct port_if* pif; 930238106Sdes /* randomly select interface and port */ 931238106Sdes if(num_if == 0) { 932238106Sdes verbose(VERB_QUERY, "Need to send query but have no " 933238106Sdes "outgoing interfaces of that family"); 934238106Sdes return 0; 935238106Sdes } 936238106Sdes log_assert(outnet->unused_fds); 937238106Sdes tries = 0; 938238106Sdes while(1) { 939238106Sdes my_if = ub_random_max(outnet->rnd, num_if); 940238106Sdes pif = &ifs[my_if]; 941238106Sdes my_port = ub_random_max(outnet->rnd, pif->avail_total); 942238106Sdes if(my_port < pif->inuse) { 943238106Sdes /* port already open */ 944238106Sdes pend->pc = pif->out[my_port]; 945238106Sdes verbose(VERB_ALGO, "using UDP if=%d port=%d", 946238106Sdes my_if, pend->pc->number); 947238106Sdes break; 948238106Sdes } 949238106Sdes /* try to open new port, if fails, loop to try again */ 950238106Sdes log_assert(pif->inuse < pif->maxout); 951238106Sdes portno = pif->avail_ports[my_port - pif->inuse]; 952238106Sdes fd = udp_sockport(&pif->addr, pif->addrlen, portno, &inuse); 953238106Sdes if(fd == -1 && !inuse) { 954238106Sdes /* nonrecoverable error making socket */ 955238106Sdes return 0; 956238106Sdes } 957238106Sdes if(fd != -1) { 958238106Sdes verbose(VERB_ALGO, "opened UDP if=%d port=%d", 959238106Sdes my_if, portno); 960238106Sdes /* grab fd */ 961238106Sdes pend->pc = outnet->unused_fds; 962238106Sdes outnet->unused_fds = pend->pc->next; 963238106Sdes 964238106Sdes /* setup portcomm */ 965238106Sdes pend->pc->next = NULL; 966238106Sdes pend->pc->number = portno; 967238106Sdes pend->pc->pif = pif; 968238106Sdes pend->pc->index = pif->inuse; 969238106Sdes pend->pc->num_outstanding = 0; 970238106Sdes comm_point_start_listening(pend->pc->cp, fd, -1); 971238106Sdes 972238106Sdes /* grab port in interface */ 973238106Sdes pif->out[pif->inuse] = pend->pc; 974238106Sdes pif->avail_ports[my_port - pif->inuse] = 975238106Sdes pif->avail_ports[pif->avail_total-pif->inuse-1]; 976238106Sdes pif->inuse++; 977238106Sdes break; 978238106Sdes } 979238106Sdes /* failed, already in use */ 980238106Sdes verbose(VERB_QUERY, "port %d in use, trying another", portno); 981238106Sdes tries++; 982238106Sdes if(tries == MAX_PORT_RETRY) { 983238106Sdes log_err("failed to find an open port, drop msg"); 984238106Sdes return 0; 985238106Sdes } 986238106Sdes } 987238106Sdes log_assert(pend->pc); 988238106Sdes pend->pc->num_outstanding++; 989238106Sdes 990238106Sdes return 1; 991238106Sdes} 992238106Sdes 993238106Sdesstatic int 994238106Sdesrandomize_and_send_udp(struct outside_network* outnet, struct pending* pend, 995269257Sdes sldns_buffer* packet, int timeout) 996238106Sdes{ 997238106Sdes struct timeval tv; 998238106Sdes 999238106Sdes /* select id */ 1000238106Sdes if(!select_id(outnet, pend, packet)) { 1001238106Sdes return 0; 1002238106Sdes } 1003238106Sdes 1004238106Sdes /* select src_if, port */ 1005238106Sdes if(addr_is_ip6(&pend->addr, pend->addrlen)) { 1006238106Sdes if(!select_ifport(outnet, pend, 1007238106Sdes outnet->num_ip6, outnet->ip6_ifs)) 1008238106Sdes return 0; 1009238106Sdes } else { 1010238106Sdes if(!select_ifport(outnet, pend, 1011238106Sdes outnet->num_ip4, outnet->ip4_ifs)) 1012238106Sdes return 0; 1013238106Sdes } 1014238106Sdes log_assert(pend->pc && pend->pc->cp); 1015238106Sdes 1016238106Sdes /* send it over the commlink */ 1017238106Sdes if(!comm_point_send_udp_msg(pend->pc->cp, packet, 1018238106Sdes (struct sockaddr*)&pend->addr, pend->addrlen)) { 1019238106Sdes portcomm_loweruse(outnet, pend->pc); 1020238106Sdes return 0; 1021238106Sdes } 1022238106Sdes 1023238106Sdes /* system calls to set timeout after sending UDP to make roundtrip 1024238106Sdes smaller. */ 1025238106Sdes#ifndef S_SPLINT_S 1026238106Sdes tv.tv_sec = timeout/1000; 1027238106Sdes tv.tv_usec = (timeout%1000)*1000; 1028238106Sdes#endif 1029238106Sdes comm_timer_set(pend->timer, &tv); 1030238106Sdes return 1; 1031238106Sdes} 1032238106Sdes 1033238106Sdesstruct pending* 1034269257Sdespending_udp_query(struct outside_network* outnet, sldns_buffer* packet, 1035238106Sdes struct sockaddr_storage* addr, socklen_t addrlen, int timeout, 1036238106Sdes comm_point_callback_t* cb, void* cb_arg) 1037238106Sdes{ 1038238106Sdes struct pending* pend = (struct pending*)calloc(1, sizeof(*pend)); 1039238106Sdes if(!pend) return NULL; 1040238106Sdes pend->outnet = outnet; 1041238106Sdes pend->addrlen = addrlen; 1042238106Sdes memmove(&pend->addr, addr, addrlen); 1043238106Sdes pend->cb = cb; 1044238106Sdes pend->cb_arg = cb_arg; 1045238106Sdes pend->node.key = pend; 1046238106Sdes pend->timer = comm_timer_create(outnet->base, pending_udp_timer_cb, 1047238106Sdes pend); 1048238106Sdes if(!pend->timer) { 1049238106Sdes free(pend); 1050238106Sdes return NULL; 1051238106Sdes } 1052238106Sdes 1053238106Sdes if(outnet->unused_fds == NULL) { 1054238106Sdes /* no unused fd, cannot create a new port (randomly) */ 1055238106Sdes verbose(VERB_ALGO, "no fds available, udp query waiting"); 1056238106Sdes pend->timeout = timeout; 1057269257Sdes pend->pkt_len = sldns_buffer_limit(packet); 1058269257Sdes pend->pkt = (uint8_t*)memdup(sldns_buffer_begin(packet), 1059238106Sdes pend->pkt_len); 1060238106Sdes if(!pend->pkt) { 1061238106Sdes comm_timer_delete(pend->timer); 1062238106Sdes free(pend); 1063238106Sdes return NULL; 1064238106Sdes } 1065238106Sdes /* put at end of waiting list */ 1066238106Sdes if(outnet->udp_wait_last) 1067238106Sdes outnet->udp_wait_last->next_waiting = pend; 1068238106Sdes else 1069238106Sdes outnet->udp_wait_first = pend; 1070238106Sdes outnet->udp_wait_last = pend; 1071238106Sdes return pend; 1072238106Sdes } 1073238106Sdes if(!randomize_and_send_udp(outnet, pend, packet, timeout)) { 1074238106Sdes pending_delete(outnet, pend); 1075238106Sdes return NULL; 1076238106Sdes } 1077238106Sdes return pend; 1078238106Sdes} 1079238106Sdes 1080238106Sdesvoid 1081238106Sdesoutnet_tcptimer(void* arg) 1082238106Sdes{ 1083238106Sdes struct waiting_tcp* w = (struct waiting_tcp*)arg; 1084238106Sdes struct outside_network* outnet = w->outnet; 1085238106Sdes comm_point_callback_t* cb; 1086238106Sdes void* cb_arg; 1087238106Sdes if(w->pkt) { 1088238106Sdes /* it is on the waiting list */ 1089238106Sdes struct waiting_tcp* p=outnet->tcp_wait_first, *prev=NULL; 1090238106Sdes while(p) { 1091238106Sdes if(p == w) { 1092238106Sdes if(prev) prev->next_waiting = w->next_waiting; 1093238106Sdes else outnet->tcp_wait_first=w->next_waiting; 1094238106Sdes outnet->tcp_wait_last = prev; 1095238106Sdes break; 1096238106Sdes } 1097238106Sdes prev = p; 1098238106Sdes p=p->next_waiting; 1099238106Sdes } 1100238106Sdes } else { 1101238106Sdes /* it was in use */ 1102238106Sdes struct pending_tcp* pend=(struct pending_tcp*)w->next_waiting; 1103238106Sdes comm_point_close(pend->c); 1104238106Sdes pend->query = NULL; 1105238106Sdes pend->next_free = outnet->tcp_free; 1106238106Sdes outnet->tcp_free = pend; 1107238106Sdes } 1108238106Sdes cb = w->cb; 1109238106Sdes cb_arg = w->cb_arg; 1110238106Sdes waiting_tcp_delete(w); 1111238106Sdes fptr_ok(fptr_whitelist_pending_tcp(cb)); 1112238106Sdes (void)(*cb)(NULL, cb_arg, NETEVENT_TIMEOUT, NULL); 1113238106Sdes use_free_buffer(outnet); 1114238106Sdes} 1115238106Sdes 1116238106Sdesstruct waiting_tcp* 1117269257Sdespending_tcp_query(struct outside_network* outnet, sldns_buffer* packet, 1118238106Sdes struct sockaddr_storage* addr, socklen_t addrlen, int timeout, 1119238106Sdes comm_point_callback_t* callback, void* callback_arg, int ssl_upstream) 1120238106Sdes{ 1121238106Sdes struct pending_tcp* pend = outnet->tcp_free; 1122238106Sdes struct waiting_tcp* w; 1123238106Sdes struct timeval tv; 1124238106Sdes uint16_t id; 1125238106Sdes /* if no buffer is free allocate space to store query */ 1126238106Sdes w = (struct waiting_tcp*)malloc(sizeof(struct waiting_tcp) 1127269257Sdes + (pend?0:sldns_buffer_limit(packet))); 1128238106Sdes if(!w) { 1129238106Sdes return NULL; 1130238106Sdes } 1131238106Sdes if(!(w->timer = comm_timer_create(outnet->base, outnet_tcptimer, w))) { 1132238106Sdes free(w); 1133238106Sdes return NULL; 1134238106Sdes } 1135238106Sdes w->pkt = NULL; 1136238106Sdes w->pkt_len = 0; 1137238106Sdes id = ((unsigned)ub_random(outnet->rnd)>>8) & 0xffff; 1138269257Sdes LDNS_ID_SET(sldns_buffer_begin(packet), id); 1139238106Sdes memcpy(&w->addr, addr, addrlen); 1140238106Sdes w->addrlen = addrlen; 1141238106Sdes w->outnet = outnet; 1142238106Sdes w->cb = callback; 1143238106Sdes w->cb_arg = callback_arg; 1144238106Sdes w->ssl_upstream = ssl_upstream; 1145238106Sdes#ifndef S_SPLINT_S 1146238106Sdes tv.tv_sec = timeout; 1147238106Sdes tv.tv_usec = 0; 1148238106Sdes#endif 1149238106Sdes comm_timer_set(w->timer, &tv); 1150238106Sdes if(pend) { 1151238106Sdes /* we have a buffer available right now */ 1152269257Sdes if(!outnet_tcp_take_into_use(w, sldns_buffer_begin(packet), 1153269257Sdes sldns_buffer_limit(packet))) { 1154238106Sdes waiting_tcp_delete(w); 1155238106Sdes return NULL; 1156238106Sdes } 1157238106Sdes } else { 1158238106Sdes /* queue up */ 1159238106Sdes w->pkt = (uint8_t*)w + sizeof(struct waiting_tcp); 1160269257Sdes w->pkt_len = sldns_buffer_limit(packet); 1161269257Sdes memmove(w->pkt, sldns_buffer_begin(packet), w->pkt_len); 1162238106Sdes w->next_waiting = NULL; 1163238106Sdes if(outnet->tcp_wait_last) 1164238106Sdes outnet->tcp_wait_last->next_waiting = w; 1165238106Sdes else outnet->tcp_wait_first = w; 1166238106Sdes outnet->tcp_wait_last = w; 1167238106Sdes } 1168238106Sdes return w; 1169238106Sdes} 1170238106Sdes 1171238106Sdes/** create query for serviced queries */ 1172238106Sdesstatic void 1173269257Sdesserviced_gen_query(sldns_buffer* buff, uint8_t* qname, size_t qnamelen, 1174238106Sdes uint16_t qtype, uint16_t qclass, uint16_t flags) 1175238106Sdes{ 1176269257Sdes sldns_buffer_clear(buff); 1177238106Sdes /* skip id */ 1178269257Sdes sldns_buffer_write_u16(buff, flags); 1179269257Sdes sldns_buffer_write_u16(buff, 1); /* qdcount */ 1180269257Sdes sldns_buffer_write_u16(buff, 0); /* ancount */ 1181269257Sdes sldns_buffer_write_u16(buff, 0); /* nscount */ 1182269257Sdes sldns_buffer_write_u16(buff, 0); /* arcount */ 1183269257Sdes sldns_buffer_write(buff, qname, qnamelen); 1184269257Sdes sldns_buffer_write_u16(buff, qtype); 1185269257Sdes sldns_buffer_write_u16(buff, qclass); 1186269257Sdes sldns_buffer_flip(buff); 1187238106Sdes} 1188238106Sdes 1189238106Sdes/** lookup serviced query in serviced query rbtree */ 1190238106Sdesstatic struct serviced_query* 1191269257Sdeslookup_serviced(struct outside_network* outnet, sldns_buffer* buff, int dnssec, 1192238106Sdes struct sockaddr_storage* addr, socklen_t addrlen) 1193238106Sdes{ 1194238106Sdes struct serviced_query key; 1195238106Sdes key.node.key = &key; 1196269257Sdes key.qbuf = sldns_buffer_begin(buff); 1197269257Sdes key.qbuflen = sldns_buffer_limit(buff); 1198238106Sdes key.dnssec = dnssec; 1199238106Sdes memcpy(&key.addr, addr, addrlen); 1200238106Sdes key.addrlen = addrlen; 1201238106Sdes key.outnet = outnet; 1202238106Sdes return (struct serviced_query*)rbtree_search(outnet->serviced, &key); 1203238106Sdes} 1204238106Sdes 1205238106Sdes/** Create new serviced entry */ 1206238106Sdesstatic struct serviced_query* 1207269257Sdesserviced_create(struct outside_network* outnet, sldns_buffer* buff, int dnssec, 1208238106Sdes int want_dnssec, int tcp_upstream, int ssl_upstream, 1209238106Sdes struct sockaddr_storage* addr, socklen_t addrlen, uint8_t* zone, 1210238106Sdes size_t zonelen, int qtype) 1211238106Sdes{ 1212238106Sdes struct serviced_query* sq = (struct serviced_query*)malloc(sizeof(*sq)); 1213238106Sdes#ifdef UNBOUND_DEBUG 1214238106Sdes rbnode_t* ins; 1215238106Sdes#endif 1216238106Sdes if(!sq) 1217238106Sdes return NULL; 1218238106Sdes sq->node.key = sq; 1219269257Sdes sq->qbuf = memdup(sldns_buffer_begin(buff), sldns_buffer_limit(buff)); 1220238106Sdes if(!sq->qbuf) { 1221238106Sdes free(sq); 1222238106Sdes return NULL; 1223238106Sdes } 1224269257Sdes sq->qbuflen = sldns_buffer_limit(buff); 1225238106Sdes sq->zone = memdup(zone, zonelen); 1226238106Sdes if(!sq->zone) { 1227238106Sdes free(sq->qbuf); 1228238106Sdes free(sq); 1229238106Sdes return NULL; 1230238106Sdes } 1231238106Sdes sq->zonelen = zonelen; 1232238106Sdes sq->qtype = qtype; 1233238106Sdes sq->dnssec = dnssec; 1234238106Sdes sq->want_dnssec = want_dnssec; 1235238106Sdes sq->tcp_upstream = tcp_upstream; 1236238106Sdes sq->ssl_upstream = ssl_upstream; 1237238106Sdes memcpy(&sq->addr, addr, addrlen); 1238238106Sdes sq->addrlen = addrlen; 1239238106Sdes sq->outnet = outnet; 1240238106Sdes sq->cblist = NULL; 1241238106Sdes sq->pending = NULL; 1242238106Sdes sq->status = serviced_initial; 1243238106Sdes sq->retry = 0; 1244238106Sdes sq->to_be_deleted = 0; 1245238106Sdes#ifdef UNBOUND_DEBUG 1246238106Sdes ins = 1247269257Sdes#else 1248269257Sdes (void) 1249238106Sdes#endif 1250238106Sdes rbtree_insert(outnet->serviced, &sq->node); 1251238106Sdes log_assert(ins != NULL); /* must not be already present */ 1252238106Sdes return sq; 1253238106Sdes} 1254238106Sdes 1255238106Sdes/** remove waiting tcp from the outnet waiting list */ 1256238106Sdesstatic void 1257238106Sdeswaiting_list_remove(struct outside_network* outnet, struct waiting_tcp* w) 1258238106Sdes{ 1259238106Sdes struct waiting_tcp* p = outnet->tcp_wait_first, *prev = NULL; 1260238106Sdes while(p) { 1261238106Sdes if(p == w) { 1262238106Sdes /* remove w */ 1263238106Sdes if(prev) 1264238106Sdes prev->next_waiting = w->next_waiting; 1265238106Sdes else outnet->tcp_wait_first = w->next_waiting; 1266238106Sdes if(outnet->tcp_wait_last == w) 1267238106Sdes outnet->tcp_wait_last = prev; 1268238106Sdes return; 1269238106Sdes } 1270238106Sdes prev = p; 1271238106Sdes p = p->next_waiting; 1272238106Sdes } 1273238106Sdes} 1274238106Sdes 1275238106Sdes/** cleanup serviced query entry */ 1276238106Sdesstatic void 1277238106Sdesserviced_delete(struct serviced_query* sq) 1278238106Sdes{ 1279238106Sdes if(sq->pending) { 1280238106Sdes /* clear up the pending query */ 1281238106Sdes if(sq->status == serviced_query_UDP_EDNS || 1282238106Sdes sq->status == serviced_query_UDP || 1283238106Sdes sq->status == serviced_query_PROBE_EDNS || 1284238106Sdes sq->status == serviced_query_UDP_EDNS_FRAG || 1285238106Sdes sq->status == serviced_query_UDP_EDNS_fallback) { 1286238106Sdes struct pending* p = (struct pending*)sq->pending; 1287238106Sdes if(p->pc) 1288238106Sdes portcomm_loweruse(sq->outnet, p->pc); 1289238106Sdes pending_delete(sq->outnet, p); 1290238106Sdes /* this call can cause reentrant calls back into the 1291238106Sdes * mesh */ 1292238106Sdes outnet_send_wait_udp(sq->outnet); 1293238106Sdes } else { 1294238106Sdes struct waiting_tcp* p = (struct waiting_tcp*) 1295238106Sdes sq->pending; 1296238106Sdes if(p->pkt == NULL) { 1297238106Sdes decomission_pending_tcp(sq->outnet, 1298238106Sdes (struct pending_tcp*)p->next_waiting); 1299238106Sdes } else { 1300238106Sdes waiting_list_remove(sq->outnet, p); 1301238106Sdes waiting_tcp_delete(p); 1302238106Sdes } 1303238106Sdes } 1304238106Sdes } 1305238106Sdes /* does not delete from tree, caller has to do that */ 1306238106Sdes serviced_node_del(&sq->node, NULL); 1307238106Sdes} 1308238106Sdes 1309238106Sdes/** perturb a dname capitalization randomly */ 1310238106Sdesstatic void 1311238106Sdesserviced_perturb_qname(struct ub_randstate* rnd, uint8_t* qbuf, size_t len) 1312238106Sdes{ 1313238106Sdes uint8_t lablen; 1314238106Sdes uint8_t* d = qbuf + 10; 1315238106Sdes long int random = 0; 1316238106Sdes int bits = 0; 1317238106Sdes log_assert(len >= 10 + 5 /* offset qname, root, qtype, qclass */); 1318238106Sdes lablen = *d++; 1319238106Sdes while(lablen) { 1320238106Sdes while(lablen--) { 1321238106Sdes /* only perturb A-Z, a-z */ 1322238106Sdes if(isalpha((int)*d)) { 1323238106Sdes /* get a random bit */ 1324238106Sdes if(bits == 0) { 1325238106Sdes random = ub_random(rnd); 1326238106Sdes bits = 30; 1327238106Sdes } 1328238106Sdes if(random & 0x1) { 1329238106Sdes *d = (uint8_t)toupper((int)*d); 1330238106Sdes } else { 1331238106Sdes *d = (uint8_t)tolower((int)*d); 1332238106Sdes } 1333238106Sdes random >>= 1; 1334238106Sdes bits--; 1335238106Sdes } 1336238106Sdes d++; 1337238106Sdes } 1338238106Sdes lablen = *d++; 1339238106Sdes } 1340238106Sdes if(verbosity >= VERB_ALGO) { 1341238106Sdes char buf[LDNS_MAX_DOMAINLEN+1]; 1342238106Sdes dname_str(qbuf+10, buf); 1343238106Sdes verbose(VERB_ALGO, "qname perturbed to %s", buf); 1344238106Sdes } 1345238106Sdes} 1346238106Sdes 1347238106Sdes/** put serviced query into a buffer */ 1348238106Sdesstatic void 1349269257Sdesserviced_encode(struct serviced_query* sq, sldns_buffer* buff, int with_edns) 1350238106Sdes{ 1351238106Sdes /* if we are using 0x20 bits for ID randomness, perturb them */ 1352238106Sdes if(sq->outnet->use_caps_for_id) { 1353238106Sdes serviced_perturb_qname(sq->outnet->rnd, sq->qbuf, sq->qbuflen); 1354238106Sdes } 1355238106Sdes /* generate query */ 1356269257Sdes sldns_buffer_clear(buff); 1357269257Sdes sldns_buffer_write_u16(buff, 0); /* id placeholder */ 1358269257Sdes sldns_buffer_write(buff, sq->qbuf, sq->qbuflen); 1359269257Sdes sldns_buffer_flip(buff); 1360238106Sdes if(with_edns) { 1361238106Sdes /* add edns section */ 1362238106Sdes struct edns_data edns; 1363238106Sdes edns.edns_present = 1; 1364238106Sdes edns.ext_rcode = 0; 1365238106Sdes edns.edns_version = EDNS_ADVERTISED_VERSION; 1366238106Sdes if(sq->status == serviced_query_UDP_EDNS_FRAG) { 1367238106Sdes if(addr_is_ip6(&sq->addr, sq->addrlen)) { 1368238106Sdes if(EDNS_FRAG_SIZE_IP6 < EDNS_ADVERTISED_SIZE) 1369238106Sdes edns.udp_size = EDNS_FRAG_SIZE_IP6; 1370238106Sdes else edns.udp_size = EDNS_ADVERTISED_SIZE; 1371238106Sdes } else { 1372238106Sdes if(EDNS_FRAG_SIZE_IP4 < EDNS_ADVERTISED_SIZE) 1373238106Sdes edns.udp_size = EDNS_FRAG_SIZE_IP4; 1374238106Sdes else edns.udp_size = EDNS_ADVERTISED_SIZE; 1375238106Sdes } 1376238106Sdes } else { 1377238106Sdes edns.udp_size = EDNS_ADVERTISED_SIZE; 1378238106Sdes } 1379238106Sdes edns.bits = 0; 1380238106Sdes if(sq->dnssec & EDNS_DO) 1381238106Sdes edns.bits = EDNS_DO; 1382238106Sdes if(sq->dnssec & BIT_CD) 1383269257Sdes LDNS_CD_SET(sldns_buffer_begin(buff)); 1384238106Sdes attach_edns_record(buff, &edns); 1385238106Sdes } 1386238106Sdes} 1387238106Sdes 1388238106Sdes/** 1389238106Sdes * Perform serviced query UDP sending operation. 1390238106Sdes * Sends UDP with EDNS, unless infra host marked non EDNS. 1391238106Sdes * @param sq: query to send. 1392238106Sdes * @param buff: buffer scratch space. 1393238106Sdes * @return 0 on error. 1394238106Sdes */ 1395238106Sdesstatic int 1396269257Sdesserviced_udp_send(struct serviced_query* sq, sldns_buffer* buff) 1397238106Sdes{ 1398238106Sdes int rtt, vs; 1399238106Sdes uint8_t edns_lame_known; 1400269257Sdes time_t now = *sq->outnet->now_secs; 1401238106Sdes 1402238106Sdes if(!infra_host(sq->outnet->infra, &sq->addr, sq->addrlen, sq->zone, 1403238106Sdes sq->zonelen, now, &vs, &edns_lame_known, &rtt)) 1404238106Sdes return 0; 1405238106Sdes sq->last_rtt = rtt; 1406238106Sdes verbose(VERB_ALGO, "EDNS lookup known=%d vs=%d", edns_lame_known, vs); 1407238106Sdes if(sq->status == serviced_initial) { 1408238106Sdes if(edns_lame_known == 0 && rtt > 5000 && rtt < 10001) { 1409238106Sdes /* perform EDNS lame probe - check if server is 1410238106Sdes * EDNS lame (EDNS queries to it are dropped) */ 1411238106Sdes verbose(VERB_ALGO, "serviced query: send probe to see " 1412238106Sdes " if use of EDNS causes timeouts"); 1413238106Sdes /* even 700 msec may be too small */ 1414238106Sdes rtt = 1000; 1415238106Sdes sq->status = serviced_query_PROBE_EDNS; 1416238106Sdes } else if(vs != -1) { 1417238106Sdes sq->status = serviced_query_UDP_EDNS; 1418238106Sdes } else { 1419238106Sdes sq->status = serviced_query_UDP; 1420238106Sdes } 1421238106Sdes } 1422238106Sdes serviced_encode(sq, buff, (sq->status == serviced_query_UDP_EDNS) || 1423238106Sdes (sq->status == serviced_query_UDP_EDNS_FRAG)); 1424238106Sdes sq->last_sent_time = *sq->outnet->now_tv; 1425238106Sdes sq->edns_lame_known = (int)edns_lame_known; 1426238106Sdes verbose(VERB_ALGO, "serviced query UDP timeout=%d msec", rtt); 1427238106Sdes sq->pending = pending_udp_query(sq->outnet, buff, &sq->addr, 1428238106Sdes sq->addrlen, rtt, serviced_udp_callback, sq); 1429238106Sdes if(!sq->pending) 1430238106Sdes return 0; 1431238106Sdes return 1; 1432238106Sdes} 1433238106Sdes 1434238106Sdes/** check that perturbed qname is identical */ 1435238106Sdesstatic int 1436269257Sdesserviced_check_qname(sldns_buffer* pkt, uint8_t* qbuf, size_t qbuflen) 1437238106Sdes{ 1438269257Sdes uint8_t* d1 = sldns_buffer_at(pkt, 12); 1439238106Sdes uint8_t* d2 = qbuf+10; 1440238106Sdes uint8_t len1, len2; 1441238106Sdes int count = 0; 1442238106Sdes log_assert(qbuflen >= 15 /* 10 header, root, type, class */); 1443238106Sdes len1 = *d1++; 1444238106Sdes len2 = *d2++; 1445269257Sdes if(sldns_buffer_limit(pkt) < 12+1+4) /* packet too small for qname */ 1446238106Sdes return 0; 1447238106Sdes while(len1 != 0 || len2 != 0) { 1448238106Sdes if(LABEL_IS_PTR(len1)) { 1449269257Sdes d1 = sldns_buffer_at(pkt, PTR_OFFSET(len1, *d1)); 1450269257Sdes if(d1 >= sldns_buffer_at(pkt, sldns_buffer_limit(pkt))) 1451238106Sdes return 0; 1452238106Sdes len1 = *d1++; 1453238106Sdes if(count++ > MAX_COMPRESS_PTRS) 1454238106Sdes return 0; 1455238106Sdes continue; 1456238106Sdes } 1457238106Sdes if(d2 > qbuf+qbuflen) 1458238106Sdes return 0; 1459238106Sdes if(len1 != len2) 1460238106Sdes return 0; 1461238106Sdes if(len1 > LDNS_MAX_LABELLEN) 1462238106Sdes return 0; 1463238106Sdes log_assert(len1 <= LDNS_MAX_LABELLEN); 1464238106Sdes log_assert(len2 <= LDNS_MAX_LABELLEN); 1465238106Sdes log_assert(len1 == len2 && len1 != 0); 1466238106Sdes /* compare the labels - bitwise identical */ 1467238106Sdes if(memcmp(d1, d2, len1) != 0) 1468238106Sdes return 0; 1469238106Sdes d1 += len1; 1470238106Sdes d2 += len2; 1471238106Sdes len1 = *d1++; 1472238106Sdes len2 = *d2++; 1473238106Sdes } 1474238106Sdes return 1; 1475238106Sdes} 1476238106Sdes 1477238106Sdes/** call the callbacks for a serviced query */ 1478238106Sdesstatic void 1479238106Sdesserviced_callbacks(struct serviced_query* sq, int error, struct comm_point* c, 1480238106Sdes struct comm_reply* rep) 1481238106Sdes{ 1482249141Sdes struct service_callback* p; 1483238106Sdes int dobackup = (sq->cblist && sq->cblist->next); /* >1 cb*/ 1484238106Sdes uint8_t *backup_p = NULL; 1485238106Sdes size_t backlen = 0; 1486238106Sdes#ifdef UNBOUND_DEBUG 1487238106Sdes rbnode_t* rem = 1488269257Sdes#else 1489269257Sdes (void) 1490238106Sdes#endif 1491238106Sdes /* remove from tree, and schedule for deletion, so that callbacks 1492238106Sdes * can safely deregister themselves and even create new serviced 1493238106Sdes * queries that are identical to this one. */ 1494238106Sdes rbtree_delete(sq->outnet->serviced, sq); 1495238106Sdes log_assert(rem); /* should have been present */ 1496238106Sdes sq->to_be_deleted = 1; 1497238106Sdes verbose(VERB_ALGO, "svcd callbacks start"); 1498238106Sdes if(sq->outnet->use_caps_for_id && error == NETEVENT_NOERROR && c) { 1499238106Sdes /* noerror and nxdomain must have a qname in reply */ 1500269257Sdes if(sldns_buffer_read_u16_at(c->buffer, 4) == 0 && 1501269257Sdes (LDNS_RCODE_WIRE(sldns_buffer_begin(c->buffer)) 1502238106Sdes == LDNS_RCODE_NOERROR || 1503269257Sdes LDNS_RCODE_WIRE(sldns_buffer_begin(c->buffer)) 1504238106Sdes == LDNS_RCODE_NXDOMAIN)) { 1505238106Sdes verbose(VERB_DETAIL, "no qname in reply to check 0x20ID"); 1506238106Sdes log_addr(VERB_DETAIL, "from server", 1507238106Sdes &sq->addr, sq->addrlen); 1508238106Sdes log_buf(VERB_DETAIL, "for packet", c->buffer); 1509238106Sdes error = NETEVENT_CLOSED; 1510238106Sdes c = NULL; 1511269257Sdes } else if(sldns_buffer_read_u16_at(c->buffer, 4) > 0 && 1512238106Sdes !serviced_check_qname(c->buffer, sq->qbuf, 1513238106Sdes sq->qbuflen)) { 1514238106Sdes verbose(VERB_DETAIL, "wrong 0x20-ID in reply qname"); 1515238106Sdes log_addr(VERB_DETAIL, "from server", 1516238106Sdes &sq->addr, sq->addrlen); 1517238106Sdes log_buf(VERB_DETAIL, "for packet", c->buffer); 1518238106Sdes error = NETEVENT_CAPSFAIL; 1519238106Sdes /* and cleanup too */ 1520238106Sdes pkt_dname_tolower(c->buffer, 1521269257Sdes sldns_buffer_at(c->buffer, 12)); 1522238106Sdes } else { 1523238106Sdes verbose(VERB_ALGO, "good 0x20-ID in reply qname"); 1524238106Sdes /* cleanup caps, prettier cache contents. */ 1525238106Sdes pkt_dname_tolower(c->buffer, 1526269257Sdes sldns_buffer_at(c->buffer, 12)); 1527238106Sdes } 1528238106Sdes } 1529238106Sdes if(dobackup && c) { 1530238106Sdes /* make a backup of the query, since the querystate processing 1531238106Sdes * may send outgoing queries that overwrite the buffer. 1532238106Sdes * use secondary buffer to store the query. 1533238106Sdes * This is a data copy, but faster than packet to server */ 1534269257Sdes backlen = sldns_buffer_limit(c->buffer); 1535269257Sdes backup_p = memdup(sldns_buffer_begin(c->buffer), backlen); 1536238106Sdes if(!backup_p) { 1537238106Sdes log_err("malloc failure in serviced query callbacks"); 1538238106Sdes error = NETEVENT_CLOSED; 1539238106Sdes c = NULL; 1540238106Sdes } 1541238106Sdes sq->outnet->svcd_overhead = backlen; 1542238106Sdes } 1543249141Sdes /* test the actual sq->cblist, because the next elem could be deleted*/ 1544249141Sdes while((p=sq->cblist) != NULL) { 1545249141Sdes sq->cblist = p->next; /* remove this element */ 1546238106Sdes if(dobackup && c) { 1547269257Sdes sldns_buffer_clear(c->buffer); 1548269257Sdes sldns_buffer_write(c->buffer, backup_p, backlen); 1549269257Sdes sldns_buffer_flip(c->buffer); 1550238106Sdes } 1551238106Sdes fptr_ok(fptr_whitelist_serviced_query(p->cb)); 1552238106Sdes (void)(*p->cb)(c, p->cb_arg, error, rep); 1553249141Sdes free(p); 1554238106Sdes } 1555238106Sdes if(backup_p) { 1556238106Sdes free(backup_p); 1557238106Sdes sq->outnet->svcd_overhead = 0; 1558238106Sdes } 1559238106Sdes verbose(VERB_ALGO, "svcd callbacks end"); 1560238106Sdes log_assert(sq->cblist == NULL); 1561238106Sdes serviced_delete(sq); 1562238106Sdes} 1563238106Sdes 1564238106Sdesint 1565238106Sdesserviced_tcp_callback(struct comm_point* c, void* arg, int error, 1566238106Sdes struct comm_reply* rep) 1567238106Sdes{ 1568238106Sdes struct serviced_query* sq = (struct serviced_query*)arg; 1569238106Sdes struct comm_reply r2; 1570238106Sdes sq->pending = NULL; /* removed after this callback */ 1571238106Sdes if(error != NETEVENT_NOERROR) 1572238106Sdes log_addr(VERB_QUERY, "tcp error for address", 1573238106Sdes &sq->addr, sq->addrlen); 1574238106Sdes if(error==NETEVENT_NOERROR) 1575238106Sdes infra_update_tcp_works(sq->outnet->infra, &sq->addr, 1576238106Sdes sq->addrlen, sq->zone, sq->zonelen); 1577238106Sdes if(error==NETEVENT_NOERROR && sq->status == serviced_query_TCP_EDNS && 1578269257Sdes (LDNS_RCODE_WIRE(sldns_buffer_begin(c->buffer)) == 1579269257Sdes LDNS_RCODE_FORMERR || LDNS_RCODE_WIRE(sldns_buffer_begin( 1580238106Sdes c->buffer)) == LDNS_RCODE_NOTIMPL) ) { 1581238106Sdes /* attempt to fallback to nonEDNS */ 1582238106Sdes sq->status = serviced_query_TCP_EDNS_fallback; 1583238106Sdes serviced_tcp_initiate(sq->outnet, sq, c->buffer); 1584238106Sdes return 0; 1585238106Sdes } else if(error==NETEVENT_NOERROR && 1586238106Sdes sq->status == serviced_query_TCP_EDNS_fallback && 1587269257Sdes (LDNS_RCODE_WIRE(sldns_buffer_begin(c->buffer)) == 1588238106Sdes LDNS_RCODE_NOERROR || LDNS_RCODE_WIRE( 1589269257Sdes sldns_buffer_begin(c->buffer)) == LDNS_RCODE_NXDOMAIN 1590269257Sdes || LDNS_RCODE_WIRE(sldns_buffer_begin(c->buffer)) 1591238106Sdes == LDNS_RCODE_YXDOMAIN)) { 1592238106Sdes /* the fallback produced a result that looks promising, note 1593238106Sdes * that this server should be approached without EDNS */ 1594238106Sdes /* only store noEDNS in cache if domain is noDNSSEC */ 1595238106Sdes if(!sq->want_dnssec) 1596238106Sdes if(!infra_edns_update(sq->outnet->infra, &sq->addr, 1597238106Sdes sq->addrlen, sq->zone, sq->zonelen, -1, 1598238106Sdes *sq->outnet->now_secs)) 1599238106Sdes log_err("Out of memory caching no edns for host"); 1600238106Sdes sq->status = serviced_query_TCP; 1601238106Sdes } 1602238106Sdes if(sq->tcp_upstream || sq->ssl_upstream) { 1603238106Sdes struct timeval now = *sq->outnet->now_tv; 1604238106Sdes if(now.tv_sec > sq->last_sent_time.tv_sec || 1605238106Sdes (now.tv_sec == sq->last_sent_time.tv_sec && 1606238106Sdes now.tv_usec > sq->last_sent_time.tv_usec)) { 1607238106Sdes /* convert from microseconds to milliseconds */ 1608269257Sdes int roundtime = ((int)(now.tv_sec - sq->last_sent_time.tv_sec))*1000 1609238106Sdes + ((int)now.tv_usec - (int)sq->last_sent_time.tv_usec)/1000; 1610238106Sdes verbose(VERB_ALGO, "measured TCP-time at %d msec", roundtime); 1611238106Sdes log_assert(roundtime >= 0); 1612238106Sdes /* only store if less then AUTH_TIMEOUT seconds, it could be 1613238106Sdes * huge due to system-hibernated and we woke up */ 1614238106Sdes if(roundtime < TCP_AUTH_QUERY_TIMEOUT*1000) { 1615238106Sdes if(!infra_rtt_update(sq->outnet->infra, &sq->addr, 1616238106Sdes sq->addrlen, sq->zone, sq->zonelen, sq->qtype, 1617269257Sdes roundtime, sq->last_rtt, (time_t)now.tv_sec)) 1618238106Sdes log_err("out of memory noting rtt."); 1619238106Sdes } 1620238106Sdes } 1621238106Sdes } 1622238106Sdes /* insert address into reply info */ 1623238106Sdes if(!rep) { 1624238106Sdes /* create one if there isn't (on errors) */ 1625238106Sdes rep = &r2; 1626238106Sdes r2.c = c; 1627238106Sdes } 1628238106Sdes memcpy(&rep->addr, &sq->addr, sq->addrlen); 1629238106Sdes rep->addrlen = sq->addrlen; 1630238106Sdes serviced_callbacks(sq, error, c, rep); 1631238106Sdes return 0; 1632238106Sdes} 1633238106Sdes 1634238106Sdesstatic void 1635238106Sdesserviced_tcp_initiate(struct outside_network* outnet, 1636269257Sdes struct serviced_query* sq, sldns_buffer* buff) 1637238106Sdes{ 1638238106Sdes verbose(VERB_ALGO, "initiate TCP query %s", 1639238106Sdes sq->status==serviced_query_TCP_EDNS?"EDNS":""); 1640238106Sdes serviced_encode(sq, buff, sq->status == serviced_query_TCP_EDNS); 1641238106Sdes sq->last_sent_time = *sq->outnet->now_tv; 1642238106Sdes sq->pending = pending_tcp_query(outnet, buff, &sq->addr, 1643238106Sdes sq->addrlen, TCP_AUTH_QUERY_TIMEOUT, serviced_tcp_callback, 1644238106Sdes sq, sq->ssl_upstream); 1645238106Sdes if(!sq->pending) { 1646238106Sdes /* delete from tree so that a retry by above layer does not 1647238106Sdes * clash with this entry */ 1648238106Sdes log_err("serviced_tcp_initiate: failed to send tcp query"); 1649238106Sdes serviced_callbacks(sq, NETEVENT_CLOSED, NULL, NULL); 1650238106Sdes } 1651238106Sdes} 1652238106Sdes 1653238106Sdes/** Send serviced query over TCP return false on initial failure */ 1654238106Sdesstatic int 1655269257Sdesserviced_tcp_send(struct serviced_query* sq, sldns_buffer* buff) 1656238106Sdes{ 1657238106Sdes int vs, rtt; 1658238106Sdes uint8_t edns_lame_known; 1659238106Sdes if(!infra_host(sq->outnet->infra, &sq->addr, sq->addrlen, sq->zone, 1660238106Sdes sq->zonelen, *sq->outnet->now_secs, &vs, &edns_lame_known, 1661238106Sdes &rtt)) 1662238106Sdes return 0; 1663238106Sdes if(vs != -1) 1664238106Sdes sq->status = serviced_query_TCP_EDNS; 1665238106Sdes else sq->status = serviced_query_TCP; 1666238106Sdes serviced_encode(sq, buff, sq->status == serviced_query_TCP_EDNS); 1667238106Sdes sq->last_sent_time = *sq->outnet->now_tv; 1668238106Sdes sq->pending = pending_tcp_query(sq->outnet, buff, &sq->addr, 1669238106Sdes sq->addrlen, TCP_AUTH_QUERY_TIMEOUT, serviced_tcp_callback, 1670238106Sdes sq, sq->ssl_upstream); 1671238106Sdes return sq->pending != NULL; 1672238106Sdes} 1673238106Sdes 1674238106Sdesint 1675238106Sdesserviced_udp_callback(struct comm_point* c, void* arg, int error, 1676238106Sdes struct comm_reply* rep) 1677238106Sdes{ 1678238106Sdes struct serviced_query* sq = (struct serviced_query*)arg; 1679238106Sdes struct outside_network* outnet = sq->outnet; 1680238106Sdes struct timeval now = *sq->outnet->now_tv; 1681238106Sdes int fallback_tcp = 0; 1682238106Sdes 1683238106Sdes sq->pending = NULL; /* removed after callback */ 1684238106Sdes if(error == NETEVENT_TIMEOUT) { 1685238106Sdes int rto = 0; 1686238106Sdes if(sq->status == serviced_query_PROBE_EDNS) { 1687238106Sdes /* non-EDNS probe failed; we do not know its status, 1688238106Sdes * keep trying with EDNS, timeout may not be caused 1689238106Sdes * by EDNS. */ 1690238106Sdes sq->status = serviced_query_UDP_EDNS; 1691238106Sdes } 1692238106Sdes if(sq->status == serviced_query_UDP_EDNS && sq->last_rtt < 5000) { 1693238106Sdes /* fallback to 1480/1280 */ 1694238106Sdes sq->status = serviced_query_UDP_EDNS_FRAG; 1695238106Sdes log_name_addr(VERB_ALGO, "try edns1xx0", sq->qbuf+10, 1696238106Sdes &sq->addr, sq->addrlen); 1697238106Sdes if(!serviced_udp_send(sq, c->buffer)) { 1698238106Sdes serviced_callbacks(sq, NETEVENT_CLOSED, c, rep); 1699238106Sdes } 1700238106Sdes return 0; 1701238106Sdes } 1702238106Sdes if(sq->status == serviced_query_UDP_EDNS_FRAG) { 1703238106Sdes /* fragmentation size did not fix it */ 1704238106Sdes sq->status = serviced_query_UDP_EDNS; 1705238106Sdes } 1706238106Sdes sq->retry++; 1707238106Sdes if(!(rto=infra_rtt_update(outnet->infra, &sq->addr, sq->addrlen, 1708238106Sdes sq->zone, sq->zonelen, sq->qtype, -1, sq->last_rtt, 1709269257Sdes (time_t)now.tv_sec))) 1710238106Sdes log_err("out of memory in UDP exponential backoff"); 1711238106Sdes if(sq->retry < OUTBOUND_UDP_RETRY) { 1712238106Sdes log_name_addr(VERB_ALGO, "retry query", sq->qbuf+10, 1713238106Sdes &sq->addr, sq->addrlen); 1714238106Sdes if(!serviced_udp_send(sq, c->buffer)) { 1715238106Sdes serviced_callbacks(sq, NETEVENT_CLOSED, c, rep); 1716238106Sdes } 1717238106Sdes return 0; 1718238106Sdes } 1719238106Sdes if(rto >= RTT_MAX_TIMEOUT) { 1720238106Sdes fallback_tcp = 1; 1721238106Sdes /* UDP does not work, fallback to TCP below */ 1722238106Sdes } else { 1723238106Sdes serviced_callbacks(sq, NETEVENT_TIMEOUT, c, rep); 1724238106Sdes return 0; 1725238106Sdes } 1726238106Sdes } else if(error != NETEVENT_NOERROR) { 1727238106Sdes /* udp returns error (due to no ID or interface available) */ 1728238106Sdes serviced_callbacks(sq, error, c, rep); 1729238106Sdes return 0; 1730238106Sdes } 1731238106Sdes if(!fallback_tcp) { 1732238106Sdes if( (sq->status == serviced_query_UDP_EDNS 1733238106Sdes ||sq->status == serviced_query_UDP_EDNS_FRAG) 1734269257Sdes && (LDNS_RCODE_WIRE(sldns_buffer_begin(c->buffer)) 1735238106Sdes == LDNS_RCODE_FORMERR || LDNS_RCODE_WIRE( 1736269257Sdes sldns_buffer_begin(c->buffer)) == LDNS_RCODE_NOTIMPL)) { 1737238106Sdes /* try to get an answer by falling back without EDNS */ 1738238106Sdes verbose(VERB_ALGO, "serviced query: attempt without EDNS"); 1739238106Sdes sq->status = serviced_query_UDP_EDNS_fallback; 1740238106Sdes sq->retry = 0; 1741238106Sdes if(!serviced_udp_send(sq, c->buffer)) { 1742238106Sdes serviced_callbacks(sq, NETEVENT_CLOSED, c, rep); 1743238106Sdes } 1744238106Sdes return 0; 1745238106Sdes } else if(sq->status == serviced_query_PROBE_EDNS) { 1746238106Sdes /* probe without EDNS succeeds, so we conclude that this 1747238106Sdes * host likely has EDNS packets dropped */ 1748238106Sdes log_addr(VERB_DETAIL, "timeouts, concluded that connection to " 1749238106Sdes "host drops EDNS packets", &sq->addr, sq->addrlen); 1750238106Sdes /* only store noEDNS in cache if domain is noDNSSEC */ 1751238106Sdes if(!sq->want_dnssec) 1752238106Sdes if(!infra_edns_update(outnet->infra, &sq->addr, sq->addrlen, 1753269257Sdes sq->zone, sq->zonelen, -1, (time_t)now.tv_sec)) { 1754238106Sdes log_err("Out of memory caching no edns for host"); 1755238106Sdes } 1756238106Sdes sq->status = serviced_query_UDP; 1757238106Sdes } else if(sq->status == serviced_query_UDP_EDNS && 1758238106Sdes !sq->edns_lame_known) { 1759238106Sdes /* now we know that edns queries received answers store that */ 1760238106Sdes log_addr(VERB_ALGO, "serviced query: EDNS works for", 1761238106Sdes &sq->addr, sq->addrlen); 1762238106Sdes if(!infra_edns_update(outnet->infra, &sq->addr, sq->addrlen, 1763269257Sdes sq->zone, sq->zonelen, 0, (time_t)now.tv_sec)) { 1764238106Sdes log_err("Out of memory caching edns works"); 1765238106Sdes } 1766238106Sdes sq->edns_lame_known = 1; 1767238106Sdes } else if(sq->status == serviced_query_UDP_EDNS_fallback && 1768238106Sdes !sq->edns_lame_known && (LDNS_RCODE_WIRE( 1769269257Sdes sldns_buffer_begin(c->buffer)) == LDNS_RCODE_NOERROR || 1770269257Sdes LDNS_RCODE_WIRE(sldns_buffer_begin(c->buffer)) == 1771269257Sdes LDNS_RCODE_NXDOMAIN || LDNS_RCODE_WIRE(sldns_buffer_begin( 1772238106Sdes c->buffer)) == LDNS_RCODE_YXDOMAIN)) { 1773238106Sdes /* the fallback produced a result that looks promising, note 1774238106Sdes * that this server should be approached without EDNS */ 1775238106Sdes /* only store noEDNS in cache if domain is noDNSSEC */ 1776238106Sdes if(!sq->want_dnssec) { 1777238106Sdes log_addr(VERB_ALGO, "serviced query: EDNS fails for", 1778238106Sdes &sq->addr, sq->addrlen); 1779238106Sdes if(!infra_edns_update(outnet->infra, &sq->addr, sq->addrlen, 1780269257Sdes sq->zone, sq->zonelen, -1, (time_t)now.tv_sec)) { 1781238106Sdes log_err("Out of memory caching no edns for host"); 1782238106Sdes } 1783238106Sdes } else { 1784238106Sdes log_addr(VERB_ALGO, "serviced query: EDNS fails, but " 1785238106Sdes "not stored because need DNSSEC for", &sq->addr, 1786238106Sdes sq->addrlen); 1787238106Sdes } 1788238106Sdes sq->status = serviced_query_UDP; 1789238106Sdes } 1790238106Sdes if(now.tv_sec > sq->last_sent_time.tv_sec || 1791238106Sdes (now.tv_sec == sq->last_sent_time.tv_sec && 1792238106Sdes now.tv_usec > sq->last_sent_time.tv_usec)) { 1793238106Sdes /* convert from microseconds to milliseconds */ 1794269257Sdes int roundtime = ((int)(now.tv_sec - sq->last_sent_time.tv_sec))*1000 1795238106Sdes + ((int)now.tv_usec - (int)sq->last_sent_time.tv_usec)/1000; 1796238106Sdes verbose(VERB_ALGO, "measured roundtrip at %d msec", roundtime); 1797238106Sdes log_assert(roundtime >= 0); 1798238106Sdes /* in case the system hibernated, do not enter a huge value, 1799238106Sdes * above this value gives trouble with server selection */ 1800238106Sdes if(roundtime < 60000) { 1801238106Sdes if(!infra_rtt_update(outnet->infra, &sq->addr, sq->addrlen, 1802238106Sdes sq->zone, sq->zonelen, sq->qtype, roundtime, 1803269257Sdes sq->last_rtt, (time_t)now.tv_sec)) 1804238106Sdes log_err("out of memory noting rtt."); 1805238106Sdes } 1806238106Sdes } 1807238106Sdes } /* end of if_!fallback_tcp */ 1808238106Sdes /* perform TC flag check and TCP fallback after updating our 1809238106Sdes * cache entries for EDNS status and RTT times */ 1810269257Sdes if(LDNS_TC_WIRE(sldns_buffer_begin(c->buffer)) || fallback_tcp) { 1811238106Sdes /* fallback to TCP */ 1812238106Sdes /* this discards partial UDP contents */ 1813238106Sdes if(sq->status == serviced_query_UDP_EDNS || 1814238106Sdes sq->status == serviced_query_UDP_EDNS_FRAG || 1815238106Sdes sq->status == serviced_query_UDP_EDNS_fallback) 1816238106Sdes /* if we have unfinished EDNS_fallback, start again */ 1817238106Sdes sq->status = serviced_query_TCP_EDNS; 1818238106Sdes else sq->status = serviced_query_TCP; 1819238106Sdes serviced_tcp_initiate(outnet, sq, c->buffer); 1820238106Sdes return 0; 1821238106Sdes } 1822238106Sdes /* yay! an answer */ 1823238106Sdes serviced_callbacks(sq, error, c, rep); 1824238106Sdes return 0; 1825238106Sdes} 1826238106Sdes 1827238106Sdesstruct serviced_query* 1828238106Sdesoutnet_serviced_query(struct outside_network* outnet, 1829238106Sdes uint8_t* qname, size_t qnamelen, uint16_t qtype, uint16_t qclass, 1830238106Sdes uint16_t flags, int dnssec, int want_dnssec, int tcp_upstream, 1831238106Sdes int ssl_upstream, struct sockaddr_storage* addr, socklen_t addrlen, 1832238106Sdes uint8_t* zone, size_t zonelen, comm_point_callback_t* callback, 1833269257Sdes void* callback_arg, sldns_buffer* buff) 1834238106Sdes{ 1835238106Sdes struct serviced_query* sq; 1836238106Sdes struct service_callback* cb; 1837238106Sdes serviced_gen_query(buff, qname, qnamelen, qtype, qclass, flags); 1838238106Sdes sq = lookup_serviced(outnet, buff, dnssec, addr, addrlen); 1839249141Sdes /* duplicate entries are included in the callback list, because 1840249141Sdes * there is a counterpart registration by our caller that needs to 1841249141Sdes * be doubly-removed (with callbacks perhaps). */ 1842238106Sdes if(!(cb = (struct service_callback*)malloc(sizeof(*cb)))) 1843238106Sdes return NULL; 1844238106Sdes if(!sq) { 1845238106Sdes /* make new serviced query entry */ 1846238106Sdes sq = serviced_create(outnet, buff, dnssec, want_dnssec, 1847238106Sdes tcp_upstream, ssl_upstream, addr, addrlen, zone, 1848238106Sdes zonelen, (int)qtype); 1849238106Sdes if(!sq) { 1850238106Sdes free(cb); 1851238106Sdes return NULL; 1852238106Sdes } 1853238106Sdes /* perform first network action */ 1854238106Sdes if(outnet->do_udp && !(tcp_upstream || ssl_upstream)) { 1855238106Sdes if(!serviced_udp_send(sq, buff)) { 1856238106Sdes (void)rbtree_delete(outnet->serviced, sq); 1857238106Sdes free(sq->qbuf); 1858238106Sdes free(sq->zone); 1859238106Sdes free(sq); 1860238106Sdes free(cb); 1861238106Sdes return NULL; 1862238106Sdes } 1863238106Sdes } else { 1864238106Sdes if(!serviced_tcp_send(sq, buff)) { 1865238106Sdes (void)rbtree_delete(outnet->serviced, sq); 1866238106Sdes free(sq->qbuf); 1867238106Sdes free(sq->zone); 1868238106Sdes free(sq); 1869238106Sdes free(cb); 1870238106Sdes return NULL; 1871238106Sdes } 1872238106Sdes } 1873238106Sdes } 1874238106Sdes /* add callback to list of callbacks */ 1875238106Sdes cb->cb = callback; 1876238106Sdes cb->cb_arg = callback_arg; 1877238106Sdes cb->next = sq->cblist; 1878238106Sdes sq->cblist = cb; 1879238106Sdes return sq; 1880238106Sdes} 1881238106Sdes 1882238106Sdes/** remove callback from list */ 1883238106Sdesstatic void 1884238106Sdescallback_list_remove(struct serviced_query* sq, void* cb_arg) 1885238106Sdes{ 1886238106Sdes struct service_callback** pp = &sq->cblist; 1887238106Sdes while(*pp) { 1888238106Sdes if((*pp)->cb_arg == cb_arg) { 1889238106Sdes struct service_callback* del = *pp; 1890238106Sdes *pp = del->next; 1891238106Sdes free(del); 1892238106Sdes return; 1893238106Sdes } 1894238106Sdes pp = &(*pp)->next; 1895238106Sdes } 1896238106Sdes} 1897238106Sdes 1898238106Sdesvoid outnet_serviced_query_stop(struct serviced_query* sq, void* cb_arg) 1899238106Sdes{ 1900238106Sdes if(!sq) 1901238106Sdes return; 1902238106Sdes callback_list_remove(sq, cb_arg); 1903238106Sdes /* if callbacks() routine scheduled deletion, let it do that */ 1904238106Sdes if(!sq->cblist && !sq->to_be_deleted) { 1905238106Sdes#ifdef UNBOUND_DEBUG 1906238106Sdes rbnode_t* rem = 1907269257Sdes#else 1908269257Sdes (void) 1909238106Sdes#endif 1910238106Sdes rbtree_delete(sq->outnet->serviced, sq); 1911238106Sdes log_assert(rem); /* should be present */ 1912238106Sdes serviced_delete(sq); 1913238106Sdes } 1914238106Sdes} 1915238106Sdes 1916238106Sdes/** get memory used by waiting tcp entry (in use or not) */ 1917238106Sdesstatic size_t 1918238106Sdeswaiting_tcp_get_mem(struct waiting_tcp* w) 1919238106Sdes{ 1920238106Sdes size_t s; 1921238106Sdes if(!w) return 0; 1922238106Sdes s = sizeof(*w) + w->pkt_len; 1923238106Sdes if(w->timer) 1924238106Sdes s += comm_timer_get_mem(w->timer); 1925238106Sdes return s; 1926238106Sdes} 1927238106Sdes 1928238106Sdes/** get memory used by port if */ 1929238106Sdesstatic size_t 1930238106Sdesif_get_mem(struct port_if* pif) 1931238106Sdes{ 1932238106Sdes size_t s; 1933238106Sdes int i; 1934238106Sdes s = sizeof(*pif) + sizeof(int)*pif->avail_total + 1935238106Sdes sizeof(struct port_comm*)*pif->maxout; 1936238106Sdes for(i=0; i<pif->inuse; i++) 1937238106Sdes s += sizeof(*pif->out[i]) + 1938238106Sdes comm_point_get_mem(pif->out[i]->cp); 1939238106Sdes return s; 1940238106Sdes} 1941238106Sdes 1942238106Sdes/** get memory used by waiting udp */ 1943238106Sdesstatic size_t 1944238106Sdeswaiting_udp_get_mem(struct pending* w) 1945238106Sdes{ 1946238106Sdes size_t s; 1947238106Sdes s = sizeof(*w) + comm_timer_get_mem(w->timer) + w->pkt_len; 1948238106Sdes return s; 1949238106Sdes} 1950238106Sdes 1951238106Sdessize_t outnet_get_mem(struct outside_network* outnet) 1952238106Sdes{ 1953238106Sdes size_t i; 1954238106Sdes int k; 1955238106Sdes struct waiting_tcp* w; 1956238106Sdes struct pending* u; 1957238106Sdes struct serviced_query* sq; 1958238106Sdes struct service_callback* sb; 1959238106Sdes struct port_comm* pc; 1960238106Sdes size_t s = sizeof(*outnet) + sizeof(*outnet->base) + 1961238106Sdes sizeof(*outnet->udp_buff) + 1962269257Sdes sldns_buffer_capacity(outnet->udp_buff); 1963238106Sdes /* second buffer is not ours */ 1964238106Sdes for(pc = outnet->unused_fds; pc; pc = pc->next) { 1965238106Sdes s += sizeof(*pc) + comm_point_get_mem(pc->cp); 1966238106Sdes } 1967238106Sdes for(k=0; k<outnet->num_ip4; k++) 1968238106Sdes s += if_get_mem(&outnet->ip4_ifs[k]); 1969238106Sdes for(k=0; k<outnet->num_ip6; k++) 1970238106Sdes s += if_get_mem(&outnet->ip6_ifs[k]); 1971238106Sdes for(u=outnet->udp_wait_first; u; u=u->next_waiting) 1972238106Sdes s += waiting_udp_get_mem(u); 1973238106Sdes 1974238106Sdes s += sizeof(struct pending_tcp*)*outnet->num_tcp; 1975238106Sdes for(i=0; i<outnet->num_tcp; i++) { 1976238106Sdes s += sizeof(struct pending_tcp); 1977238106Sdes s += comm_point_get_mem(outnet->tcp_conns[i]->c); 1978238106Sdes if(outnet->tcp_conns[i]->query) 1979238106Sdes s += waiting_tcp_get_mem(outnet->tcp_conns[i]->query); 1980238106Sdes } 1981238106Sdes for(w=outnet->tcp_wait_first; w; w = w->next_waiting) 1982238106Sdes s += waiting_tcp_get_mem(w); 1983238106Sdes s += sizeof(*outnet->pending); 1984238106Sdes s += (sizeof(struct pending) + comm_timer_get_mem(NULL)) * 1985238106Sdes outnet->pending->count; 1986238106Sdes s += sizeof(*outnet->serviced); 1987238106Sdes s += outnet->svcd_overhead; 1988238106Sdes RBTREE_FOR(sq, struct serviced_query*, outnet->serviced) { 1989238106Sdes s += sizeof(*sq) + sq->qbuflen; 1990238106Sdes for(sb = sq->cblist; sb; sb = sb->next) 1991238106Sdes s += sizeof(*sb); 1992238106Sdes } 1993238106Sdes return s; 1994238106Sdes} 1995238106Sdes 1996238106Sdessize_t 1997238106Sdesserviced_get_mem(struct serviced_query* sq) 1998238106Sdes{ 1999238106Sdes struct service_callback* sb; 2000238106Sdes size_t s; 2001238106Sdes s = sizeof(*sq) + sq->qbuflen; 2002238106Sdes for(sb = sq->cblist; sb; sb = sb->next) 2003238106Sdes s += sizeof(*sb); 2004238106Sdes if(sq->status == serviced_query_UDP_EDNS || 2005238106Sdes sq->status == serviced_query_UDP || 2006238106Sdes sq->status == serviced_query_PROBE_EDNS || 2007238106Sdes sq->status == serviced_query_UDP_EDNS_FRAG || 2008238106Sdes sq->status == serviced_query_UDP_EDNS_fallback) { 2009238106Sdes s += sizeof(struct pending); 2010238106Sdes s += comm_timer_get_mem(NULL); 2011238106Sdes } else { 2012238106Sdes /* does not have size of the pkt pointer */ 2013238106Sdes /* always has a timer except on malloc failures */ 2014238106Sdes 2015238106Sdes /* these sizes are part of the main outside network mem */ 2016238106Sdes /* 2017238106Sdes s += sizeof(struct waiting_tcp); 2018238106Sdes s += comm_timer_get_mem(NULL); 2019238106Sdes */ 2020238106Sdes } 2021238106Sdes return s; 2022238106Sdes} 2023238106Sdes 2024