contrib/unbound/services/outside_network.c

   1 /*
   2  * services/outside_network.c - implement sending of queries and wait answer.
   3  *
   4  * Copyright (c) 2007, NLnet Labs. All rights reserved.
   5  *
   6  * This software is open source.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  *
  12  * Redistributions of source code must retain the above copyright notice,
  13  * this list of conditions and the following disclaimer.
  14  *
  15  * Redistributions in binary form must reproduce the above copyright notice,
  16  * this list of conditions and the following disclaimer in the documentation
  17  * and/or other materials provided with the distribution.
  18  *
  19  * Neither the name of the NLNET LABS nor the names of its contributors may
  20  * be used to endorse or promote products derived from this software without
  21  * specific prior written permission.
  22  *
  23  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  24  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  25  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  26  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  27  * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  28  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
  29  * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  30  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  31  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  32  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  33  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  34  */
  35
  36 /**
  37  * \file
  38  *
  39  * This file has functions to send queries to authoritative servers and
  40  * wait for the pending answer events.
  41  */
  42 #include "config.h"
  43 #include <ctype.h>
  44 #ifdef HAVE_SYS_TYPES_H
  45 #  include <sys/types.h>
  46 #endif
  47 #include <sys/time.h>
  48 #include "services/outside_network.h"
  49 #include "services/listen_dnsport.h"
  50 #include "services/cache/infra.h"
  51 #include "iterator/iterator.h"
  52 #include "util/data/msgparse.h"
  53 #include "util/data/msgreply.h"
  54 #include "util/data/msgencode.h"
  55 #include "util/data/dname.h"
  56 #include "util/netevent.h"
  57 #include "util/log.h"
  58 #include "util/net_help.h"
  59 #include "util/random.h"
  60 #include "util/fptr_wlist.h"
  61 #include "sldns/sbuffer.h"
  62 #include "dnstap/dnstap.h"
  63 #ifdef HAVE_OPENSSL_SSL_H
  64 #include <openssl/ssl.h>
  65 #endif
  66
  67 #ifdef HAVE_NETDB_H
  68 #include <netdb.h>
  69 #endif
  70 #include <fcntl.h>
  71
  72 /** number of times to retry making a random ID that is unique. */
  73 #define MAX_ID_RETRY 1000
  74 /** number of times to retry finding interface, port that can be opened. */
  75 #define MAX_PORT_RETRY 10000
  76 /** number of retries on outgoing UDP queries */
  77 #define OUTBOUND_UDP_RETRY 1
  78
  79 /** initiate TCP transaction for serviced query */
  80 static void serviced_tcp_initiate(struct serviced_query* sq, sldns_buffer* buff);
  81 /** with a fd available, randomize and send UDP */
  82 static int randomize_and_send_udp(struct pending* pend, sldns_buffer* packet,
  83         int timeout);
  84
  85 /** remove waiting tcp from the outnet waiting list */
  86 static void waiting_list_remove(struct outside_network* outnet,
  87         struct waiting_tcp* w);
  88
  89 int
  90 pending_cmp(const void* key1, const void* key2)
  91 {
  92         struct pending *p1 = (struct pending*)key1;
  93         struct pending *p2 = (struct pending*)key2;
  94         if(p1->id < p2->id)
  95                 return -1;
  96         if(p1->id > p2->id)
  97                 return 1;
  98         log_assert(p1->id == p2->id);
  99         return sockaddr_cmp(&p1->addr, p1->addrlen, &p2->addr, p2->addrlen);
 100 }
 101
 102 int
 103 serviced_cmp(const void* key1, const void* key2)
 104 {
 105         struct serviced_query* q1 = (struct serviced_query*)key1;
 106         struct serviced_query* q2 = (struct serviced_query*)key2;
 107         int r;
 108         if(q1->qbuflen < q2->qbuflen)
 109                 return -1;
 110         if(q1->qbuflen > q2->qbuflen)
 111                 return 1;
 112         log_assert(q1->qbuflen == q2->qbuflen);
 113         log_assert(q1->qbuflen >= 15 /* 10 header, root, type, class */);
 114         /* alternate casing of qname is still the same query */
 115         if((r = memcmp(q1->qbuf, q2->qbuf, 10)) != 0)
 116                 return r;
 117         if((r = memcmp(q1->qbuf+q1->qbuflen-4, q2->qbuf+q2->qbuflen-4, 4)) != 0)
 118                 return r;
 119         if(q1->dnssec != q2->dnssec) {
 120                 if(q1->dnssec < q2->dnssec)
 121                         return -1;
 122                 return 1;
 123         }
 124         if((r = query_dname_compare(q1->qbuf+10, q2->qbuf+10)) != 0)
 125                 return r;
 126         if((r = edns_opt_list_compare(q1->opt_list, q2->opt_list)) != 0)
 127                 return r;
 128         return sockaddr_cmp(&q1->addr, q1->addrlen, &q2->addr, q2->addrlen);
 129 }
 130
 131 /** delete waiting_tcp entry. Does not unlink from waiting list.
 132  * @param w: to delete.
 133  */
 134 static void
 135 waiting_tcp_delete(struct waiting_tcp* w)
 136 {
 137         if(!w) return;
 138         if(w->timer)
 139                 comm_timer_delete(w->timer);
 140         free(w);
 141 }
 142
 143 /**
 144  * Pick random outgoing-interface of that family, and bind it.
 145  * port set to 0 so OS picks a port number for us.
 146  * if it is the ANY address, do not bind.
 147  * @param w: tcp structure with destination address.
 148  * @param s: socket fd.
 149  * @return false on error, socket closed.
 150  */
 151 static int
 152 pick_outgoing_tcp(struct waiting_tcp* w, int s)
 153 {
 154         struct port_if* pi = NULL;
 155         int num;
 156 #ifdef INET6
 157         if(addr_is_ip6(&w->addr, w->addrlen))
 158                 num = w->outnet->num_ip6;
 159         else
 160 #endif
 161                 num = w->outnet->num_ip4;
 162         if(num == 0) {
 163                 log_err("no TCP outgoing interfaces of family");
 164                 log_addr(VERB_OPS, "for addr", &w->addr, w->addrlen);
 165 #ifndef USE_WINSOCK
 166                 close(s);
 167 #else
 168                 closesocket(s);
 169 #endif
 170                 return 0;
 171         }
 172 #ifdef INET6
 173         if(addr_is_ip6(&w->addr, w->addrlen))
 174                 pi = &w->outnet->ip6_ifs[ub_random_max(w->outnet->rnd, num)];
 175         else
 176 #endif
 177                 pi = &w->outnet->ip4_ifs[ub_random_max(w->outnet->rnd, num)];
 178         log_assert(pi);
 179         if(addr_is_any(&pi->addr, pi->addrlen)) {
 180                 /* binding to the ANY interface is for listening sockets */
 181                 return 1;
 182         }
 183         /* set port to 0 */
 184         if(addr_is_ip6(&pi->addr, pi->addrlen))
 185                 ((struct sockaddr_in6*)&pi->addr)->sin6_port = 0;
 186         else    ((struct sockaddr_in*)&pi->addr)->sin_port = 0;
 187         if(bind(s, (struct sockaddr*)&pi->addr, pi->addrlen) != 0) {
 188 #ifndef USE_WINSOCK
 189                 log_err("outgoing tcp: bind: %s", strerror(errno));
 190                 close(s);
 191 #else
 192                 log_err("outgoing tcp: bind: %s",
 193                         wsa_strerror(WSAGetLastError()));
 194                 closesocket(s);
 195 #endif
 196                 return 0;
 197         }
 198         log_addr(VERB_ALGO, "tcp bound to src", &pi->addr, pi->addrlen);
 199         return 1;
 200 }
 201
 202 /** get TCP file descriptor for address, returns -1 on failure,
 203  * tcp_mss is 0 or maxseg size to set for TCP packets. */
 204 int
 205 outnet_get_tcp_fd(struct sockaddr_storage* addr, socklen_t addrlen, int tcp_mss)
 206 {
 207         int s;
 208 #ifdef SO_REUSEADDR
 209         int on = 1;
 210 #endif
 211 #ifdef INET6
 212         if(addr_is_ip6(addr, addrlen))
 213                 s = socket(PF_INET6, SOCK_STREAM, IPPROTO_TCP);
 214         else
 215 #endif
 216                 s = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
 217         if(s == -1) {
 218 #ifndef USE_WINSOCK
 219                 log_err_addr("outgoing tcp: socket", strerror(errno),
 220                         addr, addrlen);
 221 #else
 222                 log_err_addr("outgoing tcp: socket",
 223                         wsa_strerror(WSAGetLastError()), addr, addrlen);
 224 #endif
 225                 return -1;
 226         }
 227
 228 #ifdef SO_REUSEADDR
 229         if(setsockopt(s, SOL_SOCKET, SO_REUSEADDR, (void*)&on,
 230                 (socklen_t)sizeof(on)) < 0) {
 231                 verbose(VERB_ALGO, "outgoing tcp:"
 232                         " setsockopt(.. SO_REUSEADDR ..) failed");
 233         }
 234 #endif
 235
 236         if(tcp_mss > 0) {
 237 #if defined(IPPROTO_TCP) && defined(TCP_MAXSEG)
 238                 if(setsockopt(s, IPPROTO_TCP, TCP_MAXSEG,
 239                         (void*)&tcp_mss, (socklen_t)sizeof(tcp_mss)) < 0) {
 240                         verbose(VERB_ALGO, "outgoing tcp:"
 241                                 " setsockopt(.. TCP_MAXSEG ..) failed");
 242                 }
 243 #else
 244                 verbose(VERB_ALGO, "outgoing tcp:"
 245                         " setsockopt(TCP_MAXSEG) unsupported");
 246 #endif /* defined(IPPROTO_TCP) && defined(TCP_MAXSEG) */
 247         }
 248
 249         return s;
 250 }
 251
 252 /** connect tcp connection to addr, 0 on failure */
 253 int
 254 outnet_tcp_connect(int s, struct sockaddr_storage* addr, socklen_t addrlen)
 255 {
 256         if(connect(s, (struct sockaddr*)addr, addrlen) == -1) {
 257 #ifndef USE_WINSOCK
 258 #ifdef EINPROGRESS
 259                 if(errno != EINPROGRESS) {
 260 #endif
 261                         if(tcp_connect_errno_needs_log(
 262                                 (struct sockaddr*)addr, addrlen))
 263                                 log_err_addr("outgoing tcp: connect",
 264                                         strerror(errno), addr, addrlen);
 265                         close(s);
 266                         return 0;
 267 #ifdef EINPROGRESS
 268                 }
 269 #endif
 270 #else /* USE_WINSOCK */
 271                 if(WSAGetLastError() != WSAEINPROGRESS &&
 272                         WSAGetLastError() != WSAEWOULDBLOCK) {
 273                         closesocket(s);
 274                         return 0;
 275                 }
 276 #endif
 277         }
 278         return 1;
 279 }
 280
 281 /** use next free buffer to service a tcp query */
 282 static int
 283 outnet_tcp_take_into_use(struct waiting_tcp* w, uint8_t* pkt, size_t pkt_len)
 284 {
 285         struct pending_tcp* pend = w->outnet->tcp_free;
 286         int s;
 287         log_assert(pend);
 288         log_assert(pkt);
 289         log_assert(w->addrlen > 0);
 290         /* open socket */
 291         s = outnet_get_tcp_fd(&w->addr, w->addrlen, w->outnet->tcp_mss);
 292
 293         if(!pick_outgoing_tcp(w, s))
 294                 return 0;
 295
 296         fd_set_nonblock(s);
 297 #ifdef USE_OSX_MSG_FASTOPEN
 298         /* API for fast open is different here. We use a connectx() function and
 299            then writes can happen as normal even using SSL.*/
 300         /* connectx requires that the len be set in the sockaddr struct*/
 301         struct sockaddr_in *addr_in = (struct sockaddr_in *)&w->addr;
 302         addr_in->sin_len = w->addrlen;
 303         sa_endpoints_t endpoints;
 304         endpoints.sae_srcif = 0;
 305         endpoints.sae_srcaddr = NULL;
 306         endpoints.sae_srcaddrlen = 0;
 307         endpoints.sae_dstaddr = (struct sockaddr *)&w->addr;
 308         endpoints.sae_dstaddrlen = w->addrlen;
 309         if (connectx(s, &endpoints, SAE_ASSOCID_ANY,
 310                      CONNECT_DATA_IDEMPOTENT | CONNECT_RESUME_ON_READ_WRITE,
 311                      NULL, 0, NULL, NULL) == -1) {
 312                 /* if fails, failover to connect for OSX 10.10 */
 313 #ifdef EINPROGRESS
 314                 if(errno != EINPROGRESS) {
 315 #else
 316                 if(1) {
 317 #endif
 318                         if(connect(s, (struct sockaddr*)&w->addr, w->addrlen) == -1) {
 319 #else /* USE_OSX_MSG_FASTOPEN*/
 320 #ifdef USE_MSG_FASTOPEN
 321         pend->c->tcp_do_fastopen = 1;
 322         /* Only do TFO for TCP in which case no connect() is required here.
 323            Don't combine client TFO with SSL, since OpenSSL can't
 324            currently support doing a handshake on fd that already isn't connected*/
 325         if (w->outnet->sslctx && w->ssl_upstream) {
 326                 if(connect(s, (struct sockaddr*)&w->addr, w->addrlen) == -1) {
 327 #else /* USE_MSG_FASTOPEN*/
 328         if(connect(s, (struct sockaddr*)&w->addr, w->addrlen) == -1) {
 329 #endif /* USE_MSG_FASTOPEN*/
 330 #endif /* USE_OSX_MSG_FASTOPEN*/
 331 #ifndef USE_WINSOCK
 332 #ifdef EINPROGRESS
 333                 if(errno != EINPROGRESS) {
 334 #else
 335                 if(1) {
 336 #endif
 337                         if(tcp_connect_errno_needs_log(
 338                                 (struct sockaddr*)&w->addr, w->addrlen))
 339                                 log_err_addr("outgoing tcp: connect",
 340                                         strerror(errno), &w->addr, w->addrlen);
 341                         close(s);
 342 #else /* USE_WINSOCK */
 343                 if(WSAGetLastError() != WSAEINPROGRESS &&
 344                         WSAGetLastError() != WSAEWOULDBLOCK) {
 345                         closesocket(s);
 346 #endif
 347                         return 0;
 348                 }
 349         }
 350 #ifdef USE_MSG_FASTOPEN
 351         }
 352 #endif /* USE_MSG_FASTOPEN */
 353 #ifdef USE_OSX_MSG_FASTOPEN
 354                 }
 355         }
 356 #endif /* USE_OSX_MSG_FASTOPEN */
 357         if(w->outnet->sslctx && w->ssl_upstream) {
 358                 pend->c->ssl = outgoing_ssl_fd(w->outnet->sslctx, s);
 359                 if(!pend->c->ssl) {
 360                         pend->c->fd = s;
 361                         comm_point_close(pend->c);
 362                         return 0;
 363                 }
 364 #ifdef USE_WINSOCK
 365                 comm_point_tcp_win_bio_cb(pend->c, pend->c->ssl);
 366 #endif
 367                 pend->c->ssl_shake_state = comm_ssl_shake_write;
 368 #ifdef HAVE_SSL_SET1_HOST
 369                 if(w->tls_auth_name) {
 370                         SSL_set_verify(pend->c->ssl, SSL_VERIFY_PEER, NULL);
 371                         /* setting the hostname makes openssl verify the
 372                          * host name in the x509 certificate in the
 373                          * SSL connection*/
 374                         if(!SSL_set1_host(pend->c->ssl, w->tls_auth_name)) {
 375                                 log_err("SSL_set1_host failed");
 376                                 pend->c->fd = s;
 377                                 comm_point_close(pend->c);
 378                                 return 0;
 379                         }
 380                 }
 381 #endif /* HAVE_SSL_SET1_HOST */
 382         }
 383         w->pkt = NULL;
 384         w->next_waiting = (void*)pend;
 385         pend->id = LDNS_ID_WIRE(pkt);
 386         w->outnet->num_tcp_outgoing++;
 387         w->outnet->tcp_free = pend->next_free;
 388         pend->next_free = NULL;
 389         pend->query = w;
 390         pend->c->repinfo.addrlen = w->addrlen;
 391         memcpy(&pend->c->repinfo.addr, &w->addr, w->addrlen);
 392         sldns_buffer_clear(pend->c->buffer);
 393         sldns_buffer_write(pend->c->buffer, pkt, pkt_len);
 394         sldns_buffer_flip(pend->c->buffer);
 395         pend->c->tcp_is_reading = 0;
 396         pend->c->tcp_byte_count = 0;
 397         comm_point_start_listening(pend->c, s, -1);
 398         return 1;
 399 }
 400
 401 /** see if buffers can be used to service TCP queries */
 402 static void
 403 use_free_buffer(struct outside_network* outnet)
 404 {
 405         struct waiting_tcp* w;
 406         while(outnet->tcp_free && outnet->tcp_wait_first
 407                 && !outnet->want_to_quit) {
 408                 w = outnet->tcp_wait_first;
 409                 outnet->tcp_wait_first = w->next_waiting;
 410                 if(outnet->tcp_wait_last == w)
 411                         outnet->tcp_wait_last = NULL;
 412                 if(!outnet_tcp_take_into_use(w, w->pkt, w->pkt_len)) {
 413                         comm_point_callback_type* cb = w->cb;
 414                         void* cb_arg = w->cb_arg;
 415                         waiting_tcp_delete(w);
 416                         fptr_ok(fptr_whitelist_pending_tcp(cb));
 417                         (void)(*cb)(NULL, cb_arg, NETEVENT_CLOSED, NULL);
 418                 }
 419         }
 420 }
 421
 422 /** decommission a tcp buffer, closes commpoint and frees waiting_tcp entry */
 423 static void
 424 decommission_pending_tcp(struct outside_network* outnet,
 425         struct pending_tcp* pend)
 426 {
 427         if(pend->c->ssl) {
 428 #ifdef HAVE_SSL
 429                 SSL_shutdown(pend->c->ssl);
 430                 SSL_free(pend->c->ssl);
 431                 pend->c->ssl = NULL;
 432 #endif
 433         }
 434         comm_point_close(pend->c);
 435         pend->next_free = outnet->tcp_free;
 436         outnet->tcp_free = pend;
 437         waiting_tcp_delete(pend->query);
 438         pend->query = NULL;
 439         use_free_buffer(outnet);
 440 }
 441
 442 int
 443 outnet_tcp_cb(struct comm_point* c, void* arg, int error,
 444         struct comm_reply *reply_info)
 445 {
 446         struct pending_tcp* pend = (struct pending_tcp*)arg;
 447         struct outside_network* outnet = pend->query->outnet;
 448         verbose(VERB_ALGO, "outnettcp cb");
 449         if(error != NETEVENT_NOERROR) {
 450                 verbose(VERB_QUERY, "outnettcp got tcp error %d", error);
 451                 /* pass error below and exit */
 452         } else {
 453                 /* check ID */
 454                 if(sldns_buffer_limit(c->buffer) < sizeof(uint16_t) ||
 455                         LDNS_ID_WIRE(sldns_buffer_begin(c->buffer))!=pend->id) {
 456                         log_addr(VERB_QUERY,
 457                                 "outnettcp: bad ID in reply, from:",
 458                                 &pend->query->addr, pend->query->addrlen);
 459                         error = NETEVENT_CLOSED;
 460                 }
 461         }
 462         fptr_ok(fptr_whitelist_pending_tcp(pend->query->cb));
 463         (void)(*pend->query->cb)(c, pend->query->cb_arg, error, reply_info);
 464         decommission_pending_tcp(outnet, pend);
 465         return 0;
 466 }
 467
 468 /** lower use count on pc, see if it can be closed */
 469 static void
 470 portcomm_loweruse(struct outside_network* outnet, struct port_comm* pc)
 471 {
 472         struct port_if* pif;
 473         pc->num_outstanding--;
 474         if(pc->num_outstanding > 0) {
 475                 return;
 476         }
 477         /* close it and replace in unused list */
 478         verbose(VERB_ALGO, "close of port %d", pc->number);
 479         comm_point_close(pc->cp);
 480         pif = pc->pif;
 481         log_assert(pif->inuse > 0);
 482         pif->avail_ports[pif->avail_total - pif->inuse] = pc->number;
 483         pif->inuse--;
 484         pif->out[pc->index] = pif->out[pif->inuse];
 485         pif->out[pc->index]->index = pc->index;
 486         pc->next = outnet->unused_fds;
 487         outnet->unused_fds = pc;
 488 }
 489
 490 /** try to send waiting UDP queries */
 491 static void
 492 outnet_send_wait_udp(struct outside_network* outnet)
 493 {
 494         struct pending* pend;
 495         /* process waiting queries */
 496         while(outnet->udp_wait_first && outnet->unused_fds
 497                 && !outnet->want_to_quit) {
 498                 pend = outnet->udp_wait_first;
 499                 outnet->udp_wait_first = pend->next_waiting;
 500                 if(!pend->next_waiting) outnet->udp_wait_last = NULL;
 501                 sldns_buffer_clear(outnet->udp_buff);
 502                 sldns_buffer_write(outnet->udp_buff, pend->pkt, pend->pkt_len);
 503                 sldns_buffer_flip(outnet->udp_buff);
 504                 free(pend->pkt); /* freeing now makes get_mem correct */
 505                 pend->pkt = NULL;
 506                 pend->pkt_len = 0;
 507                 if(!randomize_and_send_udp(pend, outnet->udp_buff,
 508                         pend->timeout)) {
 509                         /* callback error on pending */
 510                         if(pend->cb) {
 511                                 fptr_ok(fptr_whitelist_pending_udp(pend->cb));
 512                                 (void)(*pend->cb)(outnet->unused_fds->cp, pend->cb_arg,
 513                                         NETEVENT_CLOSED, NULL);
 514                         }
 515                         pending_delete(outnet, pend);
 516                 }
 517         }
 518 }
 519
 520 int
 521 outnet_udp_cb(struct comm_point* c, void* arg, int error,
 522         struct comm_reply *reply_info)
 523 {
 524         struct outside_network* outnet = (struct outside_network*)arg;
 525         struct pending key;
 526         struct pending* p;
 527         verbose(VERB_ALGO, "answer cb");
 528
 529         if(error != NETEVENT_NOERROR) {
 530                 verbose(VERB_QUERY, "outnetudp got udp error %d", error);
 531                 return 0;
 532         }
 533         if(sldns_buffer_limit(c->buffer) < LDNS_HEADER_SIZE) {
 534                 verbose(VERB_QUERY, "outnetudp udp too short");
 535                 return 0;
 536         }
 537         log_assert(reply_info);
 538
 539         /* setup lookup key */
 540         key.id = (unsigned)LDNS_ID_WIRE(sldns_buffer_begin(c->buffer));
 541         memcpy(&key.addr, &reply_info->addr, reply_info->addrlen);
 542         key.addrlen = reply_info->addrlen;
 543         verbose(VERB_ALGO, "Incoming reply id = %4.4x", key.id);
 544         log_addr(VERB_ALGO, "Incoming reply addr =",
 545                 &reply_info->addr, reply_info->addrlen);
 546
 547         /* find it, see if this thing is a valid query response */
 548         verbose(VERB_ALGO, "lookup size is %d entries", (int)outnet->pending->count);
 549         p = (struct pending*)rbtree_search(outnet->pending, &key);
 550         if(!p) {
 551                 verbose(VERB_QUERY, "received unwanted or unsolicited udp reply dropped.");
 552                 log_buf(VERB_ALGO, "dropped message", c->buffer);
 553                 outnet->unwanted_replies++;
 554                 if(outnet->unwanted_threshold && ++outnet->unwanted_total
 555                         >= outnet->unwanted_threshold) {
 556                         log_warn("unwanted reply total reached threshold (%u)"
 557                                 " you may be under attack."
 558                                 " defensive action: clearing the cache",
 559                                 (unsigned)outnet->unwanted_threshold);
 560                         fptr_ok(fptr_whitelist_alloc_cleanup(
 561                                 outnet->unwanted_action));
 562                         (*outnet->unwanted_action)(outnet->unwanted_param);
 563                         outnet->unwanted_total = 0;
 564                 }
 565                 return 0;
 566         }
 567
 568         verbose(VERB_ALGO, "received udp reply.");
 569         log_buf(VERB_ALGO, "udp message", c->buffer);
 570         if(p->pc->cp != c) {
 571                 verbose(VERB_QUERY, "received reply id,addr on wrong port. "
 572                         "dropped.");
 573                 outnet->unwanted_replies++;
 574                 if(outnet->unwanted_threshold && ++outnet->unwanted_total
 575                         >= outnet->unwanted_threshold) {
 576                         log_warn("unwanted reply total reached threshold (%u)"
 577                                 " you may be under attack."
 578                                 " defensive action: clearing the cache",
 579                                 (unsigned)outnet->unwanted_threshold);
 580                         fptr_ok(fptr_whitelist_alloc_cleanup(
 581                                 outnet->unwanted_action));
 582                         (*outnet->unwanted_action)(outnet->unwanted_param);
 583                         outnet->unwanted_total = 0;
 584                 }
 585                 return 0;
 586         }
 587         comm_timer_disable(p->timer);
 588         verbose(VERB_ALGO, "outnet handle udp reply");
 589         /* delete from tree first in case callback creates a retry */
 590         (void)rbtree_delete(outnet->pending, p->node.key);
 591         if(p->cb) {
 592                 fptr_ok(fptr_whitelist_pending_udp(p->cb));
 593                 (void)(*p->cb)(p->pc->cp, p->cb_arg, NETEVENT_NOERROR, reply_info);
 594         }
 595         portcomm_loweruse(outnet, p->pc);
 596         pending_delete(NULL, p);
 597         outnet_send_wait_udp(outnet);
 598         return 0;
 599 }
 600
 601 /** calculate number of ip4 and ip6 interfaces*/
 602 static void
 603 calc_num46(char** ifs, int num_ifs, int do_ip4, int do_ip6,
 604         int* num_ip4, int* num_ip6)
 605 {
 606         int i;
 607         *num_ip4 = 0;
 608         *num_ip6 = 0;
 609         if(num_ifs <= 0) {
 610                 if(do_ip4)
 611                         *num_ip4 = 1;
 612                 if(do_ip6)
 613                         *num_ip6 = 1;
 614                 return;
 615         }
 616         for(i=0; i<num_ifs; i++)
 617         {
 618                 if(str_is_ip6(ifs[i])) {
 619                         if(do_ip6)
 620                                 (*num_ip6)++;
 621                 } else {
 622                         if(do_ip4)
 623                                 (*num_ip4)++;
 624                 }
 625         }
 626
 627 }
 628
 629 void
 630 pending_udp_timer_delay_cb(void* arg)
 631 {
 632         struct pending* p = (struct pending*)arg;
 633         struct outside_network* outnet = p->outnet;
 634         verbose(VERB_ALGO, "timeout udp with delay");
 635         portcomm_loweruse(outnet, p->pc);
 636         pending_delete(outnet, p);
 637         outnet_send_wait_udp(outnet);
 638 }
 639
 640 void
 641 pending_udp_timer_cb(void *arg)
 642 {
 643         struct pending* p = (struct pending*)arg;
 644         struct outside_network* outnet = p->outnet;
 645         /* it timed out */
 646         verbose(VERB_ALGO, "timeout udp");
 647         if(p->cb) {
 648                 fptr_ok(fptr_whitelist_pending_udp(p->cb));
 649                 (void)(*p->cb)(p->pc->cp, p->cb_arg, NETEVENT_TIMEOUT, NULL);
 650         }
 651         /* if delayclose, keep port open for a longer time.
 652          * But if the udpwaitlist exists, then we are struggling to
 653          * keep up with demand for sockets, so do not wait, but service
 654          * the customer (customer service more important than portICMPs) */
 655         if(outnet->delayclose && !outnet->udp_wait_first) {
 656                 p->cb = NULL;
 657                 p->timer->callback = &pending_udp_timer_delay_cb;
 658                 comm_timer_set(p->timer, &outnet->delay_tv);
 659                 return;
 660         }
 661         portcomm_loweruse(outnet, p->pc);
 662         pending_delete(outnet, p);
 663         outnet_send_wait_udp(outnet);
 664 }
 665
 666 /** create pending_tcp buffers */
 667 static int
 668 create_pending_tcp(struct outside_network* outnet, size_t bufsize)
 669 {
 670         size_t i;
 671         if(outnet->num_tcp == 0)
 672                 return 1; /* no tcp needed, nothing to do */
 673         if(!(outnet->tcp_conns = (struct pending_tcp **)calloc(
 674                         outnet->num_tcp, sizeof(struct pending_tcp*))))
 675                 return 0;
 676         for(i=0; i<outnet->num_tcp; i++) {
 677                 if(!(outnet->tcp_conns[i] = (struct pending_tcp*)calloc(1,
 678                         sizeof(struct pending_tcp))))
 679                         return 0;
 680                 outnet->tcp_conns[i]->next_free = outnet->tcp_free;
 681                 outnet->tcp_free = outnet->tcp_conns[i];
 682                 outnet->tcp_conns[i]->c = comm_point_create_tcp_out(
 683                         outnet->base, bufsize, outnet_tcp_cb,
 684                         outnet->tcp_conns[i]);
 685                 if(!outnet->tcp_conns[i]->c)
 686                         return 0;
 687         }
 688         return 1;
 689 }
 690
 691 /** setup an outgoing interface, ready address */
 692 static int setup_if(struct port_if* pif, const char* addrstr,
 693         int* avail, int numavail, size_t numfd)
 694 {
 695         pif->avail_total = numavail;
 696         pif->avail_ports = (int*)memdup(avail, (size_t)numavail*sizeof(int));
 697         if(!pif->avail_ports)
 698                 return 0;
 699         if(!ipstrtoaddr(addrstr, UNBOUND_DNS_PORT, &pif->addr, &pif->addrlen) &&
 700            !netblockstrtoaddr(addrstr, UNBOUND_DNS_PORT,
 701                               &pif->addr, &pif->addrlen, &pif->pfxlen))
 702                 return 0;
 703         pif->maxout = (int)numfd;
 704         pif->inuse = 0;
 705         pif->out = (struct port_comm**)calloc(numfd,
 706                 sizeof(struct port_comm*));
 707         if(!pif->out)
 708                 return 0;
 709         return 1;
 710 }
 711
 712 struct outside_network*
 713 outside_network_create(struct comm_base *base, size_t bufsize,
 714         size_t num_ports, char** ifs, int num_ifs, int do_ip4,
 715         int do_ip6, size_t num_tcp, struct infra_cache* infra,
 716         struct ub_randstate* rnd, int use_caps_for_id, int* availports,
 717         int numavailports, size_t unwanted_threshold, int tcp_mss,
 718         void (*unwanted_action)(void*), void* unwanted_param, int do_udp,
 719         void* sslctx, int delayclose, struct dt_env* dtenv)
 720 {
 721         struct outside_network* outnet = (struct outside_network*)
 722                 calloc(1, sizeof(struct outside_network));
 723         size_t k;
 724         if(!outnet) {
 725                 log_err("malloc failed");
 726                 return NULL;
 727         }
 728         comm_base_timept(base, &outnet->now_secs, &outnet->now_tv);
 729         outnet->base = base;
 730         outnet->num_tcp = num_tcp;
 731         outnet->num_tcp_outgoing = 0;
 732         outnet->infra = infra;
 733         outnet->rnd = rnd;
 734         outnet->sslctx = sslctx;
 735 #ifdef USE_DNSTAP
 736         outnet->dtenv = dtenv;
 737 #else
 738         (void)dtenv;
 739 #endif
 740         outnet->svcd_overhead = 0;
 741         outnet->want_to_quit = 0;
 742         outnet->unwanted_threshold = unwanted_threshold;
 743         outnet->unwanted_action = unwanted_action;
 744         outnet->unwanted_param = unwanted_param;
 745         outnet->use_caps_for_id = use_caps_for_id;
 746         outnet->do_udp = do_udp;
 747         outnet->tcp_mss = tcp_mss;
 748 #ifndef S_SPLINT_S
 749         if(delayclose) {
 750                 outnet->delayclose = 1;
 751                 outnet->delay_tv.tv_sec = delayclose/1000;
 752                 outnet->delay_tv.tv_usec = (delayclose%1000)*1000;
 753         }
 754 #endif
 755         if(numavailports == 0) {
 756                 log_err("no outgoing ports available");
 757                 outside_network_delete(outnet);
 758                 return NULL;
 759         }
 760 #ifndef INET6
 761         do_ip6 = 0;
 762 #endif
 763         calc_num46(ifs, num_ifs, do_ip4, do_ip6,
 764                 &outnet->num_ip4, &outnet->num_ip6);
 765         if(outnet->num_ip4 != 0) {
 766                 if(!(outnet->ip4_ifs = (struct port_if*)calloc(
 767                         (size_t)outnet->num_ip4, sizeof(struct port_if)))) {
 768                         log_err("malloc failed");
 769                         outside_network_delete(outnet);
 770                         return NULL;
 771                 }
 772         }
 773         if(outnet->num_ip6 != 0) {
 774                 if(!(outnet->ip6_ifs = (struct port_if*)calloc(
 775                         (size_t)outnet->num_ip6, sizeof(struct port_if)))) {
 776                         log_err("malloc failed");
 777                         outside_network_delete(outnet);
 778                         return NULL;
 779                 }
 780         }
 781         if(     !(outnet->udp_buff = sldns_buffer_new(bufsize)) ||
 782                 !(outnet->pending = rbtree_create(pending_cmp)) ||
 783                 !(outnet->serviced = rbtree_create(serviced_cmp)) ||
 784                 !create_pending_tcp(outnet, bufsize)) {
 785                 log_err("malloc failed");
 786                 outside_network_delete(outnet);
 787                 return NULL;
 788         }
 789
 790         /* allocate commpoints */
 791         for(k=0; k<num_ports; k++) {
 792                 struct port_comm* pc;
 793                 pc = (struct port_comm*)calloc(1, sizeof(*pc));
 794                 if(!pc) {
 795                         log_err("malloc failed");
 796                         outside_network_delete(outnet);
 797                         return NULL;
 798                 }
 799                 pc->cp = comm_point_create_udp(outnet->base, -1,
 800                         outnet->udp_buff, outnet_udp_cb, outnet);
 801                 if(!pc->cp) {
 802                         log_err("malloc failed");
 803                         free(pc);
 804                         outside_network_delete(outnet);
 805                         return NULL;
 806                 }
 807                 pc->next = outnet->unused_fds;
 808                 outnet->unused_fds = pc;
 809         }
 810
 811         /* allocate interfaces */
 812         if(num_ifs == 0) {
 813                 if(do_ip4 && !setup_if(&outnet->ip4_ifs[0], "0.0.0.0",
 814                         availports, numavailports, num_ports)) {
 815                         log_err("malloc failed");
 816                         outside_network_delete(outnet);
 817                         return NULL;
 818                 }
 819                 if(do_ip6 && !setup_if(&outnet->ip6_ifs[0], "::",
 820                         availports, numavailports, num_ports)) {
 821                         log_err("malloc failed");
 822                         outside_network_delete(outnet);
 823                         return NULL;
 824                 }
 825         } else {
 826                 size_t done_4 = 0, done_6 = 0;
 827                 int i;
 828                 for(i=0; i<num_ifs; i++) {
 829                         if(str_is_ip6(ifs[i]) && do_ip6) {
 830                                 if(!setup_if(&outnet->ip6_ifs[done_6], ifs[i],
 831                                         availports, numavailports, num_ports)){
 832                                         log_err("malloc failed");
 833                                         outside_network_delete(outnet);
 834                                         return NULL;
 835                                 }
 836                                 done_6++;
 837                         }
 838                         if(!str_is_ip6(ifs[i]) && do_ip4) {
 839                                 if(!setup_if(&outnet->ip4_ifs[done_4], ifs[i],
 840                                         availports, numavailports, num_ports)){
 841                                         log_err("malloc failed");
 842                                         outside_network_delete(outnet);
 843                                         return NULL;
 844                                 }
 845                                 done_4++;
 846                         }
 847                 }
 848         }
 849         return outnet;
 850 }
 851
 852 /** helper pending delete */
 853 static void
 854 pending_node_del(rbnode_type* node, void* arg)
 855 {
 856         struct pending* pend = (struct pending*)node;
 857         struct outside_network* outnet = (struct outside_network*)arg;
 858         pending_delete(outnet, pend);
 859 }
 860
 861 /** helper serviced delete */
 862 static void
 863 serviced_node_del(rbnode_type* node, void* ATTR_UNUSED(arg))
 864 {
 865         struct serviced_query* sq = (struct serviced_query*)node;
 866         struct service_callback* p = sq->cblist, *np;
 867         free(sq->qbuf);
 868         free(sq->zone);
 869         free(sq->tls_auth_name);
 870         edns_opt_list_free(sq->opt_list);
 871         while(p) {
 872                 np = p->next;
 873                 free(p);
 874                 p = np;
 875         }
 876         free(sq);
 877 }
 878
 879 void
 880 outside_network_quit_prepare(struct outside_network* outnet)
 881 {
 882         if(!outnet)
 883                 return;
 884         /* prevent queued items from being sent */
 885         outnet->want_to_quit = 1;
 886 }
 887
 888 void
 889 outside_network_delete(struct outside_network* outnet)
 890 {
 891         if(!outnet)
 892                 return;
 893         outnet->want_to_quit = 1;
 894         /* check every element, since we can be called on malloc error */
 895         if(outnet->pending) {
 896                 /* free pending elements, but do no unlink from tree. */
 897                 traverse_postorder(outnet->pending, pending_node_del, NULL);
 898                 free(outnet->pending);
 899         }
 900         if(outnet->serviced) {
 901                 traverse_postorder(outnet->serviced, serviced_node_del, NULL);
 902                 free(outnet->serviced);
 903         }
 904         if(outnet->udp_buff)
 905                 sldns_buffer_free(outnet->udp_buff);
 906         if(outnet->unused_fds) {
 907                 struct port_comm* p = outnet->unused_fds, *np;
 908                 while(p) {
 909                         np = p->next;
 910                         comm_point_delete(p->cp);
 911                         free(p);
 912                         p = np;
 913                 }
 914                 outnet->unused_fds = NULL;
 915         }
 916         if(outnet->ip4_ifs) {
 917                 int i, k;
 918                 for(i=0; i<outnet->num_ip4; i++) {
 919                         for(k=0; k<outnet->ip4_ifs[i].inuse; k++) {
 920                                 struct port_comm* pc = outnet->ip4_ifs[i].
 921                                         out[k];
 922                                 comm_point_delete(pc->cp);
 923                                 free(pc);
 924                         }
 925                         free(outnet->ip4_ifs[i].avail_ports);
 926                         free(outnet->ip4_ifs[i].out);
 927                 }
 928                 free(outnet->ip4_ifs);
 929         }
 930         if(outnet->ip6_ifs) {
 931                 int i, k;
 932                 for(i=0; i<outnet->num_ip6; i++) {
 933                         for(k=0; k<outnet->ip6_ifs[i].inuse; k++) {
 934                                 struct port_comm* pc = outnet->ip6_ifs[i].
 935                                         out[k];
 936                                 comm_point_delete(pc->cp);
 937                                 free(pc);
 938                         }
 939                         free(outnet->ip6_ifs[i].avail_ports);
 940                         free(outnet->ip6_ifs[i].out);
 941                 }
 942                 free(outnet->ip6_ifs);
 943         }
 944         if(outnet->tcp_conns) {
 945                 size_t i;
 946                 for(i=0; i<outnet->num_tcp; i++)
 947                         if(outnet->tcp_conns[i]) {
 948                                 comm_point_delete(outnet->tcp_conns[i]->c);
 949                                 waiting_tcp_delete(outnet->tcp_conns[i]->query);
 950                                 free(outnet->tcp_conns[i]);
 951                         }
 952                 free(outnet->tcp_conns);
 953         }
 954         if(outnet->tcp_wait_first) {
 955                 struct waiting_tcp* p = outnet->tcp_wait_first, *np;
 956                 while(p) {
 957                         np = p->next_waiting;
 958                         waiting_tcp_delete(p);
 959                         p = np;
 960                 }
 961         }
 962         if(outnet->udp_wait_first) {
 963                 struct pending* p = outnet->udp_wait_first, *np;
 964                 while(p) {
 965                         np = p->next_waiting;
 966                         pending_delete(NULL, p);
 967                         p = np;
 968                 }
 969         }
 970         free(outnet);
 971 }
 972
 973 void
 974 pending_delete(struct outside_network* outnet, struct pending* p)
 975 {
 976         if(!p)
 977                 return;
 978         if(outnet && outnet->udp_wait_first &&
 979                 (p->next_waiting || p == outnet->udp_wait_last) ) {
 980                 /* delete from waiting list, if it is in the waiting list */
 981                 struct pending* prev = NULL, *x = outnet->udp_wait_first;
 982                 while(x && x != p) {
 983                         prev = x;
 984                         x = x->next_waiting;
 985                 }
 986                 if(x) {
 987                         log_assert(x == p);
 988                         if(prev)
 989                                 prev->next_waiting = p->next_waiting;
 990                         else    outnet->udp_wait_first = p->next_waiting;
 991                         if(outnet->udp_wait_last == p)
 992                                 outnet->udp_wait_last = prev;
 993                 }
 994         }
 995         if(outnet) {
 996                 (void)rbtree_delete(outnet->pending, p->node.key);
 997         }
 998         if(p->timer)
 999                 comm_timer_delete(p->timer);
1000         free(p->pkt);
1001         free(p);
1002 }
1003
1004 static void
1005 sai6_putrandom(struct sockaddr_in6 *sa, int pfxlen, struct ub_randstate *rnd)
1006 {
1007         int i, last;
1008         if(!(pfxlen > 0 && pfxlen < 128))
1009                 return;
1010         for(i = 0; i < (128 - pfxlen) / 8; i++) {
1011                 sa->sin6_addr.s6_addr[15-i] = (uint8_t)ub_random_max(rnd, 256);
1012         }
1013         last = pfxlen & 7;
1014         if(last != 0) {
1015                 sa->sin6_addr.s6_addr[15-i] |=
1016                         ((0xFF >> last) & ub_random_max(rnd, 256));
1017         }
1018 }
1019
1020 /**
1021  * Try to open a UDP socket for outgoing communication.
1022  * Sets sockets options as needed.
1023  * @param addr: socket address.
1024  * @param addrlen: length of address.
1025  * @param pfxlen: length of network prefix (for address randomisation).
1026  * @param port: port override for addr.
1027  * @param inuse: if -1 is returned, this bool means the port was in use.
1028  * @param rnd: random state (for address randomisation).
1029  * @return fd or -1
1030  */
1031 static int
1032 udp_sockport(struct sockaddr_storage* addr, socklen_t addrlen, int pfxlen,
1033         int port, int* inuse, struct ub_randstate* rnd)
1034 {
1035         int fd, noproto;
1036         if(addr_is_ip6(addr, addrlen)) {
1037                 int freebind = 0;
1038                 struct sockaddr_in6 sa = *(struct sockaddr_in6*)addr;
1039                 sa.sin6_port = (in_port_t)htons((uint16_t)port);
1040                 sa.sin6_flowinfo = 0;
1041                 sa.sin6_scope_id = 0;
1042                 if(pfxlen != 0) {
1043                         freebind = 1;
1044                         sai6_putrandom(&sa, pfxlen, rnd);
1045                 }
1046                 fd = create_udp_sock(AF_INET6, SOCK_DGRAM,
1047                         (struct sockaddr*)&sa, addrlen, 1, inuse, &noproto,
1048                         0, 0, 0, NULL, 0, freebind, 0);
1049         } else {
1050                 struct sockaddr_in* sa = (struct sockaddr_in*)addr;
1051                 sa->sin_port = (in_port_t)htons((uint16_t)port);
1052                 fd = create_udp_sock(AF_INET, SOCK_DGRAM,
1053                         (struct sockaddr*)addr, addrlen, 1, inuse, &noproto,
1054                         0, 0, 0, NULL, 0, 0, 0);
1055         }
1056         return fd;
1057 }
1058
1059 /** Select random ID */
1060 static int
1061 select_id(struct outside_network* outnet, struct pending* pend,
1062         sldns_buffer* packet)
1063 {
1064         int id_tries = 0;
1065         pend->id = ((unsigned)ub_random(outnet->rnd)>>8) & 0xffff;
1066         LDNS_ID_SET(sldns_buffer_begin(packet), pend->id);
1067
1068         /* insert in tree */
1069         pend->node.key = pend;
1070         while(!rbtree_insert(outnet->pending, &pend->node)) {
1071                 /* change ID to avoid collision */
1072                 pend->id = ((unsigned)ub_random(outnet->rnd)>>8) & 0xffff;
1073                 LDNS_ID_SET(sldns_buffer_begin(packet), pend->id);
1074                 id_tries++;
1075                 if(id_tries == MAX_ID_RETRY) {
1076                         pend->id=99999; /* non existant ID */
1077                         log_err("failed to generate unique ID, drop msg");
1078                         return 0;
1079                 }
1080         }
1081         verbose(VERB_ALGO, "inserted new pending reply id=%4.4x", pend->id);
1082         return 1;
1083 }
1084
1085 /** Select random interface and port */
1086 static int
1087 select_ifport(struct outside_network* outnet, struct pending* pend,
1088         int num_if, struct port_if* ifs)
1089 {
1090         int my_if, my_port, fd, portno, inuse, tries=0;
1091         struct port_if* pif;
1092         /* randomly select interface and port */
1093         if(num_if == 0) {
1094                 verbose(VERB_QUERY, "Need to send query but have no "
1095                         "outgoing interfaces of that family");
1096                 return 0;
1097         }
1098         log_assert(outnet->unused_fds);
1099         tries = 0;
1100         while(1) {
1101                 my_if = ub_random_max(outnet->rnd, num_if);
1102                 pif = &ifs[my_if];
1103                 my_port = ub_random_max(outnet->rnd, pif->avail_total);
1104                 if(my_port < pif->inuse) {
1105                         /* port already open */
1106                         pend->pc = pif->out[my_port];
1107                         verbose(VERB_ALGO, "using UDP if=%d port=%d",
1108                                 my_if, pend->pc->number);
1109                         break;
1110                 }
1111                 /* try to open new port, if fails, loop to try again */
1112                 log_assert(pif->inuse < pif->maxout);
1113                 portno = pif->avail_ports[my_port - pif->inuse];
1114                 fd = udp_sockport(&pif->addr, pif->addrlen, pif->pfxlen,
1115                         portno, &inuse, outnet->rnd);
1116                 if(fd == -1 && !inuse) {
1117                         /* nonrecoverable error making socket */
1118                         return 0;
1119                 }
1120                 if(fd != -1) {
1121                         verbose(VERB_ALGO, "opened UDP if=%d port=%d",
1122                                 my_if, portno);
1123                         /* grab fd */
1124                         pend->pc = outnet->unused_fds;
1125                         outnet->unused_fds = pend->pc->next;
1126
1127                         /* setup portcomm */
1128                         pend->pc->next = NULL;
1129                         pend->pc->number = portno;
1130                         pend->pc->pif = pif;
1131                         pend->pc->index = pif->inuse;
1132                         pend->pc->num_outstanding = 0;
1133                         comm_point_start_listening(pend->pc->cp, fd, -1);
1134
1135                         /* grab port in interface */
1136                         pif->out[pif->inuse] = pend->pc;
1137                         pif->avail_ports[my_port - pif->inuse] =
1138                                 pif->avail_ports[pif->avail_total-pif->inuse-1];
1139                         pif->inuse++;
1140                         break;
1141                 }
1142                 /* failed, already in use */
1143                 verbose(VERB_QUERY, "port %d in use, trying another", portno);
1144                 tries++;
1145                 if(tries == MAX_PORT_RETRY) {
1146                         log_err("failed to find an open port, drop msg");
1147                         return 0;
1148                 }
1149         }
1150         log_assert(pend->pc);
1151         pend->pc->num_outstanding++;
1152
1153         return 1;
1154 }
1155
1156 static int
1157 randomize_and_send_udp(struct pending* pend, sldns_buffer* packet, int timeout)
1158 {
1159         struct timeval tv;
1160         struct outside_network* outnet = pend->sq->outnet;
1161
1162         /* select id */
1163         if(!select_id(outnet, pend, packet)) {
1164                 return 0;
1165         }
1166
1167         /* select src_if, port */
1168         if(addr_is_ip6(&pend->addr, pend->addrlen)) {
1169                 if(!select_ifport(outnet, pend,
1170                         outnet->num_ip6, outnet->ip6_ifs))
1171                         return 0;
1172         } else {
1173                 if(!select_ifport(outnet, pend,
1174                         outnet->num_ip4, outnet->ip4_ifs))
1175                         return 0;
1176         }
1177         log_assert(pend->pc && pend->pc->cp);
1178
1179         /* send it over the commlink */
1180         if(!comm_point_send_udp_msg(pend->pc->cp, packet,
1181                 (struct sockaddr*)&pend->addr, pend->addrlen)) {
1182                 portcomm_loweruse(outnet, pend->pc);
1183                 return 0;
1184         }
1185
1186         /* system calls to set timeout after sending UDP to make roundtrip
1187            smaller. */
1188 #ifndef S_SPLINT_S
1189         tv.tv_sec = timeout/1000;
1190         tv.tv_usec = (timeout%1000)*1000;
1191 #endif
1192         comm_timer_set(pend->timer, &tv);
1193
1194 #ifdef USE_DNSTAP
1195         if(outnet->dtenv &&
1196            (outnet->dtenv->log_resolver_query_messages ||
1197             outnet->dtenv->log_forwarder_query_messages))
1198                 dt_msg_send_outside_query(outnet->dtenv, &pend->addr, comm_udp,
1199                 pend->sq->zone, pend->sq->zonelen, packet);
1200 #endif
1201         return 1;
1202 }
1203
1204 struct pending*
1205 pending_udp_query(struct serviced_query* sq, struct sldns_buffer* packet,
1206         int timeout, comm_point_callback_type* cb, void* cb_arg)
1207 {
1208         struct pending* pend = (struct pending*)calloc(1, sizeof(*pend));
1209         if(!pend) return NULL;
1210         pend->outnet = sq->outnet;
1211         pend->sq = sq;
1212         pend->addrlen = sq->addrlen;
1213         memmove(&pend->addr, &sq->addr, sq->addrlen);
1214         pend->cb = cb;
1215         pend->cb_arg = cb_arg;
1216         pend->node.key = pend;
1217         pend->timer = comm_timer_create(sq->outnet->base, pending_udp_timer_cb,
1218                 pend);
1219         if(!pend->timer) {
1220                 free(pend);
1221                 return NULL;
1222         }
1223
1224         if(sq->outnet->unused_fds == NULL) {
1225                 /* no unused fd, cannot create a new port (randomly) */
1226                 verbose(VERB_ALGO, "no fds available, udp query waiting");
1227                 pend->timeout = timeout;
1228                 pend->pkt_len = sldns_buffer_limit(packet);
1229                 pend->pkt = (uint8_t*)memdup(sldns_buffer_begin(packet),
1230                         pend->pkt_len);
1231                 if(!pend->pkt) {
1232                         comm_timer_delete(pend->timer);
1233                         free(pend);
1234                         return NULL;
1235                 }
1236                 /* put at end of waiting list */
1237                 if(sq->outnet->udp_wait_last)
1238                         sq->outnet->udp_wait_last->next_waiting = pend;
1239                 else
1240                         sq->outnet->udp_wait_first = pend;
1241                 sq->outnet->udp_wait_last = pend;
1242                 return pend;
1243         }
1244         if(!randomize_and_send_udp(pend, packet, timeout)) {
1245                 pending_delete(sq->outnet, pend);
1246                 return NULL;
1247         }
1248         return pend;
1249 }
1250
1251 void
1252 outnet_tcptimer(void* arg)
1253 {
1254         struct waiting_tcp* w = (struct waiting_tcp*)arg;
1255         struct outside_network* outnet = w->outnet;
1256         comm_point_callback_type* cb;
1257         void* cb_arg;
1258         if(w->pkt) {
1259                 /* it is on the waiting list */
1260                 waiting_list_remove(outnet, w);
1261         } else {
1262                 /* it was in use */
1263                 struct pending_tcp* pend=(struct pending_tcp*)w->next_waiting;
1264                 comm_point_close(pend->c);
1265                 pend->query = NULL;
1266                 pend->next_free = outnet->tcp_free;
1267                 outnet->tcp_free = pend;
1268         }
1269         cb = w->cb;
1270         cb_arg = w->cb_arg;
1271         waiting_tcp_delete(w);
1272         fptr_ok(fptr_whitelist_pending_tcp(cb));
1273         (void)(*cb)(NULL, cb_arg, NETEVENT_TIMEOUT, NULL);
1274         use_free_buffer(outnet);
1275 }
1276
1277 struct waiting_tcp*
1278 pending_tcp_query(struct serviced_query* sq, sldns_buffer* packet,
1279         int timeout, comm_point_callback_type* callback, void* callback_arg)
1280 {
1281         struct pending_tcp* pend = sq->outnet->tcp_free;
1282         struct waiting_tcp* w;
1283         struct timeval tv;
1284         uint16_t id;
1285         /* if no buffer is free allocate space to store query */
1286         w = (struct waiting_tcp*)malloc(sizeof(struct waiting_tcp)
1287                 + (pend?0:sldns_buffer_limit(packet)));
1288         if(!w) {
1289                 return NULL;
1290         }
1291         if(!(w->timer = comm_timer_create(sq->outnet->base, outnet_tcptimer, w))) {
1292                 free(w);
1293                 return NULL;
1294         }
1295         w->pkt = NULL;
1296         w->pkt_len = 0;
1297         id = ((unsigned)ub_random(sq->outnet->rnd)>>8) & 0xffff;
1298         LDNS_ID_SET(sldns_buffer_begin(packet), id);
1299         memcpy(&w->addr, &sq->addr, sq->addrlen);
1300         w->addrlen = sq->addrlen;
1301         w->outnet = sq->outnet;
1302         w->cb = callback;
1303         w->cb_arg = callback_arg;
1304         w->ssl_upstream = sq->ssl_upstream;
1305         w->tls_auth_name = sq->tls_auth_name;
1306 #ifndef S_SPLINT_S
1307         tv.tv_sec = timeout/1000;
1308         tv.tv_usec = (timeout%1000)*1000;
1309 #endif
1310         comm_timer_set(w->timer, &tv);
1311         if(pend) {
1312                 /* we have a buffer available right now */
1313                 if(!outnet_tcp_take_into_use(w, sldns_buffer_begin(packet),
1314                         sldns_buffer_limit(packet))) {
1315                         waiting_tcp_delete(w);
1316                         return NULL;
1317                 }
1318 #ifdef USE_DNSTAP
1319                 if(sq->outnet->dtenv &&
1320                    (sq->outnet->dtenv->log_resolver_query_messages ||
1321                     sq->outnet->dtenv->log_forwarder_query_messages))
1322                 dt_msg_send_outside_query(sq->outnet->dtenv, &sq->addr,
1323                 comm_tcp, sq->zone, sq->zonelen, packet);
1324 #endif
1325         } else {
1326                 /* queue up */
1327                 w->pkt = (uint8_t*)w + sizeof(struct waiting_tcp);
1328                 w->pkt_len = sldns_buffer_limit(packet);
1329                 memmove(w->pkt, sldns_buffer_begin(packet), w->pkt_len);
1330                 w->next_waiting = NULL;
1331                 if(sq->outnet->tcp_wait_last)
1332                         sq->outnet->tcp_wait_last->next_waiting = w;
1333                 else    sq->outnet->tcp_wait_first = w;
1334                 sq->outnet->tcp_wait_last = w;
1335         }
1336         return w;
1337 }
1338
1339 /** create query for serviced queries */
1340 static void
1341 serviced_gen_query(sldns_buffer* buff, uint8_t* qname, size_t qnamelen,
1342         uint16_t qtype, uint16_t qclass, uint16_t flags)
1343 {
1344         sldns_buffer_clear(buff);
1345         /* skip id */
1346         sldns_buffer_write_u16(buff, flags);
1347         sldns_buffer_write_u16(buff, 1); /* qdcount */
1348         sldns_buffer_write_u16(buff, 0); /* ancount */
1349         sldns_buffer_write_u16(buff, 0); /* nscount */
1350         sldns_buffer_write_u16(buff, 0); /* arcount */
1351         sldns_buffer_write(buff, qname, qnamelen);
1352         sldns_buffer_write_u16(buff, qtype);
1353         sldns_buffer_write_u16(buff, qclass);
1354         sldns_buffer_flip(buff);
1355 }
1356
1357 /** lookup serviced query in serviced query rbtree */
1358 static struct serviced_query*
1359 lookup_serviced(struct outside_network* outnet, sldns_buffer* buff, int dnssec,
1360         struct sockaddr_storage* addr, socklen_t addrlen,
1361         struct edns_option* opt_list)
1362 {
1363         struct serviced_query key;
1364         key.node.key = &key;
1365         key.qbuf = sldns_buffer_begin(buff);
1366         key.qbuflen = sldns_buffer_limit(buff);
1367         key.dnssec = dnssec;
1368         memcpy(&key.addr, addr, addrlen);
1369         key.addrlen = addrlen;
1370         key.outnet = outnet;
1371         key.opt_list = opt_list;
1372         return (struct serviced_query*)rbtree_search(outnet->serviced, &key);
1373 }
1374
1375 /** Create new serviced entry */
1376 static struct serviced_query*
1377 serviced_create(struct outside_network* outnet, sldns_buffer* buff, int dnssec,
1378         int want_dnssec, int nocaps, int tcp_upstream, int ssl_upstream,
1379         char* tls_auth_name, struct sockaddr_storage* addr, socklen_t addrlen,
1380         uint8_t* zone, size_t zonelen, int qtype, struct edns_option* opt_list)
1381 {
1382         struct serviced_query* sq = (struct serviced_query*)malloc(sizeof(*sq));
1383 #ifdef UNBOUND_DEBUG
1384         rbnode_type* ins;
1385 #endif
1386         if(!sq)
1387                 return NULL;
1388         sq->node.key = sq;
1389         sq->qbuf = memdup(sldns_buffer_begin(buff), sldns_buffer_limit(buff));
1390         if(!sq->qbuf) {
1391                 free(sq);
1392                 return NULL;
1393         }
1394         sq->qbuflen = sldns_buffer_limit(buff);
1395         sq->zone = memdup(zone, zonelen);
1396         if(!sq->zone) {
1397                 free(sq->qbuf);
1398                 free(sq);
1399                 return NULL;
1400         }
1401         sq->zonelen = zonelen;
1402         sq->qtype = qtype;
1403         sq->dnssec = dnssec;
1404         sq->want_dnssec = want_dnssec;
1405         sq->nocaps = nocaps;
1406         sq->tcp_upstream = tcp_upstream;
1407         sq->ssl_upstream = ssl_upstream;
1408         if(tls_auth_name) {
1409                 sq->tls_auth_name = strdup(tls_auth_name);
1410                 if(!sq->tls_auth_name) {
1411                         free(sq->zone);
1412                         free(sq->qbuf);
1413                         free(sq);
1414                         return NULL;
1415                 }
1416         } else {
1417                 sq->tls_auth_name = NULL;
1418         }
1419         memcpy(&sq->addr, addr, addrlen);
1420         sq->addrlen = addrlen;
1421         sq->opt_list = NULL;
1422         if(opt_list) {
1423                 sq->opt_list = edns_opt_copy_alloc(opt_list);
1424                 if(!sq->opt_list) {
1425                         free(sq->tls_auth_name);
1426                         free(sq->zone);
1427                         free(sq->qbuf);
1428                         free(sq);
1429                         return NULL;
1430                 }
1431         }
1432         sq->outnet = outnet;
1433         sq->cblist = NULL;
1434         sq->pending = NULL;
1435         sq->status = serviced_initial;
1436         sq->retry = 0;
1437         sq->to_be_deleted = 0;
1438 #ifdef UNBOUND_DEBUG
1439         ins =
1440 #else
1441         (void)
1442 #endif
1443         rbtree_insert(outnet->serviced, &sq->node);
1444         log_assert(ins != NULL); /* must not be already present */
1445         return sq;
1446 }
1447
1448 /** remove waiting tcp from the outnet waiting list */
1449 static void
1450 waiting_list_remove(struct outside_network* outnet, struct waiting_tcp* w)
1451 {
1452         struct waiting_tcp* p = outnet->tcp_wait_first, *prev = NULL;
1453         while(p) {
1454                 if(p == w) {
1455                         /* remove w */
1456                         if(prev)
1457                                 prev->next_waiting = w->next_waiting;
1458                         else    outnet->tcp_wait_first = w->next_waiting;
1459                         if(outnet->tcp_wait_last == w)
1460                                 outnet->tcp_wait_last = prev;
1461                         return;
1462                 }
1463                 prev = p;
1464                 p = p->next_waiting;
1465         }
1466 }
1467
1468 /** cleanup serviced query entry */
1469 static void
1470 serviced_delete(struct serviced_query* sq)
1471 {
1472         if(sq->pending) {
1473                 /* clear up the pending query */
1474                 if(sq->status == serviced_query_UDP_EDNS ||
1475                         sq->status == serviced_query_UDP ||
1476                         sq->status == serviced_query_PROBE_EDNS ||
1477                         sq->status == serviced_query_UDP_EDNS_FRAG ||
1478                         sq->status == serviced_query_UDP_EDNS_fallback) {
1479                         struct pending* p = (struct pending*)sq->pending;
1480                         if(p->pc)
1481                                 portcomm_loweruse(sq->outnet, p->pc);
1482                         pending_delete(sq->outnet, p);
1483                         /* this call can cause reentrant calls back into the
1484                          * mesh */
1485                         outnet_send_wait_udp(sq->outnet);
1486                 } else {
1487                         struct waiting_tcp* p = (struct waiting_tcp*)
1488                                 sq->pending;
1489                         if(p->pkt == NULL) {
1490                                 decommission_pending_tcp(sq->outnet,
1491                                         (struct pending_tcp*)p->next_waiting);
1492                         } else {
1493                                 waiting_list_remove(sq->outnet, p);
1494                                 waiting_tcp_delete(p);
1495                         }
1496                 }
1497         }
1498         /* does not delete from tree, caller has to do that */
1499         serviced_node_del(&sq->node, NULL);
1500 }
1501
1502 /** perturb a dname capitalization randomly */
1503 static void
1504 serviced_perturb_qname(struct ub_randstate* rnd, uint8_t* qbuf, size_t len)
1505 {
1506         uint8_t lablen;
1507         uint8_t* d = qbuf + 10;
1508         long int random = 0;
1509         int bits = 0;
1510         log_assert(len >= 10 + 5 /* offset qname, root, qtype, qclass */);
1511         (void)len;
1512         lablen = *d++;
1513         while(lablen) {
1514                 while(lablen--) {
1515                         /* only perturb A-Z, a-z */
1516                         if(isalpha((unsigned char)*d)) {
1517                                 /* get a random bit */
1518                                 if(bits == 0) {
1519                                         random = ub_random(rnd);
1520                                         bits = 30;
1521                                 }
1522                                 if(random & 0x1) {
1523                                         *d = (uint8_t)toupper((unsigned char)*d);
1524                                 } else {
1525                                         *d = (uint8_t)tolower((unsigned char)*d);
1526                                 }
1527                                 random >>= 1;
1528                                 bits--;
1529                         }
1530                         d++;
1531                 }
1532                 lablen = *d++;
1533         }
1534         if(verbosity >= VERB_ALGO) {
1535                 char buf[LDNS_MAX_DOMAINLEN+1];
1536                 dname_str(qbuf+10, buf);
1537                 verbose(VERB_ALGO, "qname perturbed to %s", buf);
1538         }
1539 }
1540
1541 /** put serviced query into a buffer */
1542 static void
1543 serviced_encode(struct serviced_query* sq, sldns_buffer* buff, int with_edns)
1544 {
1545         /* if we are using 0x20 bits for ID randomness, perturb them */
1546         if(sq->outnet->use_caps_for_id && !sq->nocaps) {
1547                 serviced_perturb_qname(sq->outnet->rnd, sq->qbuf, sq->qbuflen);
1548         }
1549         /* generate query */
1550         sldns_buffer_clear(buff);
1551         sldns_buffer_write_u16(buff, 0); /* id placeholder */
1552         sldns_buffer_write(buff, sq->qbuf, sq->qbuflen);
1553         sldns_buffer_flip(buff);
1554         if(with_edns) {
1555                 /* add edns section */
1556                 struct edns_data edns;
1557                 edns.edns_present = 1;
1558                 edns.ext_rcode = 0;
1559                 edns.edns_version = EDNS_ADVERTISED_VERSION;
1560                 edns.opt_list = sq->opt_list;
1561                 if(sq->status == serviced_query_UDP_EDNS_FRAG) {
1562                         if(addr_is_ip6(&sq->addr, sq->addrlen)) {
1563                                 if(EDNS_FRAG_SIZE_IP6 < EDNS_ADVERTISED_SIZE)
1564                                         edns.udp_size = EDNS_FRAG_SIZE_IP6;
1565                                 else    edns.udp_size = EDNS_ADVERTISED_SIZE;
1566                         } else {
1567                                 if(EDNS_FRAG_SIZE_IP4 < EDNS_ADVERTISED_SIZE)
1568                                         edns.udp_size = EDNS_FRAG_SIZE_IP4;
1569                                 else    edns.udp_size = EDNS_ADVERTISED_SIZE;
1570                         }
1571                 } else {
1572                         edns.udp_size = EDNS_ADVERTISED_SIZE;
1573                 }
1574                 edns.bits = 0;
1575                 if(sq->dnssec & EDNS_DO)
1576                         edns.bits = EDNS_DO;
1577                 if(sq->dnssec & BIT_CD)
1578                         LDNS_CD_SET(sldns_buffer_begin(buff));
1579                 attach_edns_record(buff, &edns);
1580         }
1581 }
1582
1583 /**
1584  * Perform serviced query UDP sending operation.
1585  * Sends UDP with EDNS, unless infra host marked non EDNS.
1586  * @param sq: query to send.
1587  * @param buff: buffer scratch space.
1588  * @return 0 on error.
1589  */
1590 static int
1591 serviced_udp_send(struct serviced_query* sq, sldns_buffer* buff)
1592 {
1593         int rtt, vs;
1594         uint8_t edns_lame_known;
1595         time_t now = *sq->outnet->now_secs;
1596
1597         if(!infra_host(sq->outnet->infra, &sq->addr, sq->addrlen, sq->zone,
1598                 sq->zonelen, now, &vs, &edns_lame_known, &rtt))
1599                 return 0;
1600         sq->last_rtt = rtt;
1601         verbose(VERB_ALGO, "EDNS lookup known=%d vs=%d", edns_lame_known, vs);
1602         if(sq->status == serviced_initial) {
1603                 if(edns_lame_known == 0 && rtt > 5000 && rtt < 10001) {
1604                         /* perform EDNS lame probe - check if server is
1605                          * EDNS lame (EDNS queries to it are dropped) */
1606                         verbose(VERB_ALGO, "serviced query: send probe to see "
1607                                 " if use of EDNS causes timeouts");
1608                         /* even 700 msec may be too small */
1609                         rtt = 1000;
1610                         sq->status = serviced_query_PROBE_EDNS;
1611                 } else if(vs != -1) {
1612                         sq->status = serviced_query_UDP_EDNS;
1613                 } else {
1614                         sq->status = serviced_query_UDP;
1615                 }
1616         }
1617         serviced_encode(sq, buff, (sq->status == serviced_query_UDP_EDNS) ||
1618                 (sq->status == serviced_query_UDP_EDNS_FRAG));
1619         sq->last_sent_time = *sq->outnet->now_tv;
1620         sq->edns_lame_known = (int)edns_lame_known;
1621         verbose(VERB_ALGO, "serviced query UDP timeout=%d msec", rtt);
1622         sq->pending = pending_udp_query(sq, buff, rtt,
1623                 serviced_udp_callback, sq);
1624         if(!sq->pending)
1625                 return 0;
1626         return 1;
1627 }
1628
1629 /** check that perturbed qname is identical */
1630 static int
1631 serviced_check_qname(sldns_buffer* pkt, uint8_t* qbuf, size_t qbuflen)
1632 {
1633         uint8_t* d1 = sldns_buffer_begin(pkt)+12;
1634         uint8_t* d2 = qbuf+10;
1635         uint8_t len1, len2;
1636         int count = 0;
1637         if(sldns_buffer_limit(pkt) < 12+1+4) /* packet too small for qname */
1638                 return 0;
1639         log_assert(qbuflen >= 15 /* 10 header, root, type, class */);
1640         len1 = *d1++;
1641         len2 = *d2++;
1642         while(len1 != 0 || len2 != 0) {
1643                 if(LABEL_IS_PTR(len1)) {
1644                         /* check if we can read *d1 with compression ptr rest */
1645                         if(d1 >= sldns_buffer_at(pkt, sldns_buffer_limit(pkt)))
1646                                 return 0;
1647                         d1 = sldns_buffer_begin(pkt)+PTR_OFFSET(len1, *d1);
1648                         /* check if we can read the destination *d1 */
1649                         if(d1 >= sldns_buffer_at(pkt, sldns_buffer_limit(pkt)))
1650                                 return 0;
1651                         len1 = *d1++;
1652                         if(count++ > MAX_COMPRESS_PTRS)
1653                                 return 0;
1654                         continue;
1655                 }
1656                 if(d2 > qbuf+qbuflen)
1657                         return 0;
1658                 if(len1 != len2)
1659                         return 0;
1660                 if(len1 > LDNS_MAX_LABELLEN)
1661                         return 0;
1662                 /* check len1 + 1(next length) are okay to read */
1663                 if(d1+len1 >= sldns_buffer_at(pkt, sldns_buffer_limit(pkt)))
1664                         return 0;
1665                 log_assert(len1 <= LDNS_MAX_LABELLEN);
1666                 log_assert(len2 <= LDNS_MAX_LABELLEN);
1667                 log_assert(len1 == len2 && len1 != 0);
1668                 /* compare the labels - bitwise identical */
1669                 if(memcmp(d1, d2, len1) != 0)
1670                         return 0;
1671                 d1 += len1;
1672                 d2 += len2;
1673                 len1 = *d1++;
1674                 len2 = *d2++;
1675         }
1676         return 1;
1677 }
1678
1679 /** call the callbacks for a serviced query */
1680 static void
1681 serviced_callbacks(struct serviced_query* sq, int error, struct comm_point* c,
1682         struct comm_reply* rep)
1683 {
1684         struct service_callback* p;
1685         int dobackup = (sq->cblist && sq->cblist->next); /* >1 cb*/
1686         uint8_t *backup_p = NULL;
1687         size_t backlen = 0;
1688 #ifdef UNBOUND_DEBUG
1689         rbnode_type* rem =
1690 #else
1691         (void)
1692 #endif
1693         /* remove from tree, and schedule for deletion, so that callbacks
1694          * can safely deregister themselves and even create new serviced
1695          * queries that are identical to this one. */
1696         rbtree_delete(sq->outnet->serviced, sq);
1697         log_assert(rem); /* should have been present */
1698         sq->to_be_deleted = 1;
1699         verbose(VERB_ALGO, "svcd callbacks start");
1700         if(sq->outnet->use_caps_for_id && error == NETEVENT_NOERROR && c &&
1701                 !sq->nocaps && sq->qtype != LDNS_RR_TYPE_PTR) {
1702                 /* for type PTR do not check perturbed name in answer,
1703                  * compatibility with cisco dns guard boxes that mess up
1704                  * reverse queries 0x20 contents */
1705                 /* noerror and nxdomain must have a qname in reply */
1706                 if(sldns_buffer_read_u16_at(c->buffer, 4) == 0 &&
1707                         (LDNS_RCODE_WIRE(sldns_buffer_begin(c->buffer))
1708                                 == LDNS_RCODE_NOERROR ||
1709                          LDNS_RCODE_WIRE(sldns_buffer_begin(c->buffer))
1710                                 == LDNS_RCODE_NXDOMAIN)) {
1711                         verbose(VERB_DETAIL, "no qname in reply to check 0x20ID");
1712                         log_addr(VERB_DETAIL, "from server",
1713                                 &sq->addr, sq->addrlen);
1714                         log_buf(VERB_DETAIL, "for packet", c->buffer);
1715                         error = NETEVENT_CLOSED;
1716                         c = NULL;
1717                 } else if(sldns_buffer_read_u16_at(c->buffer, 4) > 0 &&
1718                         !serviced_check_qname(c->buffer, sq->qbuf,
1719                         sq->qbuflen)) {
1720                         verbose(VERB_DETAIL, "wrong 0x20-ID in reply qname");
1721                         log_addr(VERB_DETAIL, "from server",
1722                                 &sq->addr, sq->addrlen);
1723                         log_buf(VERB_DETAIL, "for packet", c->buffer);
1724                         error = NETEVENT_CAPSFAIL;
1725                         /* and cleanup too */
1726                         pkt_dname_tolower(c->buffer,
1727                                 sldns_buffer_at(c->buffer, 12));
1728                 } else {
1729                         verbose(VERB_ALGO, "good 0x20-ID in reply qname");
1730                         /* cleanup caps, prettier cache contents. */
1731                         pkt_dname_tolower(c->buffer,
1732                                 sldns_buffer_at(c->buffer, 12));
1733                 }
1734         }
1735         if(dobackup && c) {
1736                 /* make a backup of the query, since the querystate processing
1737                  * may send outgoing queries that overwrite the buffer.
1738                  * use secondary buffer to store the query.
1739                  * This is a data copy, but faster than packet to server */
1740                 backlen = sldns_buffer_limit(c->buffer);
1741                 backup_p = memdup(sldns_buffer_begin(c->buffer), backlen);
1742                 if(!backup_p) {
1743                         log_err("malloc failure in serviced query callbacks");
1744                         error = NETEVENT_CLOSED;
1745                         c = NULL;
1746                 }
1747                 sq->outnet->svcd_overhead = backlen;
1748         }
1749         /* test the actual sq->cblist, because the next elem could be deleted*/
1750         while((p=sq->cblist) != NULL) {
1751                 sq->cblist = p->next; /* remove this element */
1752                 if(dobackup && c) {
1753                         sldns_buffer_clear(c->buffer);
1754                         sldns_buffer_write(c->buffer, backup_p, backlen);
1755                         sldns_buffer_flip(c->buffer);
1756                 }
1757                 fptr_ok(fptr_whitelist_serviced_query(p->cb));
1758                 (void)(*p->cb)(c, p->cb_arg, error, rep);
1759                 free(p);
1760         }
1761         if(backup_p) {
1762                 free(backup_p);
1763                 sq->outnet->svcd_overhead = 0;
1764         }
1765         verbose(VERB_ALGO, "svcd callbacks end");
1766         log_assert(sq->cblist == NULL);
1767         serviced_delete(sq);
1768 }
1769
1770 int
1771 serviced_tcp_callback(struct comm_point* c, void* arg, int error,
1772         struct comm_reply* rep)
1773 {
1774         struct serviced_query* sq = (struct serviced_query*)arg;
1775         struct comm_reply r2;
1776         sq->pending = NULL; /* removed after this callback */
1777         if(error != NETEVENT_NOERROR)
1778                 log_addr(VERB_QUERY, "tcp error for address",
1779                         &sq->addr, sq->addrlen);
1780         if(error==NETEVENT_NOERROR)
1781                 infra_update_tcp_works(sq->outnet->infra, &sq->addr,
1782                         sq->addrlen, sq->zone, sq->zonelen);
1783 #ifdef USE_DNSTAP
1784         if(error==NETEVENT_NOERROR && sq->outnet->dtenv &&
1785            (sq->outnet->dtenv->log_resolver_response_messages ||
1786             sq->outnet->dtenv->log_forwarder_response_messages))
1787                 dt_msg_send_outside_response(sq->outnet->dtenv, &sq->addr,
1788                 c->type, sq->zone, sq->zonelen, sq->qbuf, sq->qbuflen,
1789                 &sq->last_sent_time, sq->outnet->now_tv, c->buffer);
1790 #endif
1791         if(error==NETEVENT_NOERROR && sq->status == serviced_query_TCP_EDNS &&
1792                 (LDNS_RCODE_WIRE(sldns_buffer_begin(c->buffer)) ==
1793                 LDNS_RCODE_FORMERR || LDNS_RCODE_WIRE(sldns_buffer_begin(
1794                 c->buffer)) == LDNS_RCODE_NOTIMPL) ) {
1795                 /* attempt to fallback to nonEDNS */
1796                 sq->status = serviced_query_TCP_EDNS_fallback;
1797                 serviced_tcp_initiate(sq, c->buffer);
1798                 return 0;
1799         } else if(error==NETEVENT_NOERROR &&
1800                 sq->status == serviced_query_TCP_EDNS_fallback &&
1801                         (LDNS_RCODE_WIRE(sldns_buffer_begin(c->buffer)) ==
1802                         LDNS_RCODE_NOERROR || LDNS_RCODE_WIRE(
1803                         sldns_buffer_begin(c->buffer)) == LDNS_RCODE_NXDOMAIN
1804                         || LDNS_RCODE_WIRE(sldns_buffer_begin(c->buffer))
1805                         == LDNS_RCODE_YXDOMAIN)) {
1806                 /* the fallback produced a result that looks promising, note
1807                  * that this server should be approached without EDNS */
1808                 /* only store noEDNS in cache if domain is noDNSSEC */
1809                 if(!sq->want_dnssec)
1810                   if(!infra_edns_update(sq->outnet->infra, &sq->addr,
1811                         sq->addrlen, sq->zone, sq->zonelen, -1,
1812                         *sq->outnet->now_secs))
1813                         log_err("Out of memory caching no edns for host");
1814                 sq->status = serviced_query_TCP;
1815         }
1816         if(sq->tcp_upstream || sq->ssl_upstream) {
1817             struct timeval now = *sq->outnet->now_tv;
1818             if(error!=NETEVENT_NOERROR) {
1819                 if(!infra_rtt_update(sq->outnet->infra, &sq->addr,
1820                     sq->addrlen, sq->zone, sq->zonelen, sq->qtype,
1821                     -1, sq->last_rtt, (time_t)now.tv_sec))
1822                     log_err("out of memory in TCP exponential backoff.");
1823             } else if(now.tv_sec > sq->last_sent_time.tv_sec ||
1824                 (now.tv_sec == sq->last_sent_time.tv_sec &&
1825                 now.tv_usec > sq->last_sent_time.tv_usec)) {
1826                 /* convert from microseconds to milliseconds */
1827                 int roundtime = ((int)(now.tv_sec - sq->last_sent_time.tv_sec))*1000
1828                   + ((int)now.tv_usec - (int)sq->last_sent_time.tv_usec)/1000;
1829                 verbose(VERB_ALGO, "measured TCP-time at %d msec", roundtime);
1830                 log_assert(roundtime >= 0);
1831                 /* only store if less then AUTH_TIMEOUT seconds, it could be
1832                  * huge due to system-hibernated and we woke up */
1833                 if(roundtime < 60000) {
1834                     if(!infra_rtt_update(sq->outnet->infra, &sq->addr,
1835                         sq->addrlen, sq->zone, sq->zonelen, sq->qtype,
1836                         roundtime, sq->last_rtt, (time_t)now.tv_sec))
1837                         log_err("out of memory noting rtt.");
1838                 }
1839             }
1840         }
1841         /* insert address into reply info */
1842         if(!rep) {
1843                 /* create one if there isn't (on errors) */
1844                 rep = &r2;
1845                 r2.c = c;
1846         }
1847         memcpy(&rep->addr, &sq->addr, sq->addrlen);
1848         rep->addrlen = sq->addrlen;
1849         serviced_callbacks(sq, error, c, rep);
1850         return 0;
1851 }
1852
1853 static void
1854 serviced_tcp_initiate(struct serviced_query* sq, sldns_buffer* buff)
1855 {
1856         verbose(VERB_ALGO, "initiate TCP query %s",
1857                 sq->status==serviced_query_TCP_EDNS?"EDNS":"");
1858         serviced_encode(sq, buff, sq->status == serviced_query_TCP_EDNS);
1859         sq->last_sent_time = *sq->outnet->now_tv;
1860         sq->pending = pending_tcp_query(sq, buff, TCP_AUTH_QUERY_TIMEOUT,
1861                 serviced_tcp_callback, sq);
1862         if(!sq->pending) {
1863                 /* delete from tree so that a retry by above layer does not
1864                  * clash with this entry */
1865                 log_err("serviced_tcp_initiate: failed to send tcp query");
1866                 serviced_callbacks(sq, NETEVENT_CLOSED, NULL, NULL);
1867         }
1868 }
1869
1870 /** Send serviced query over TCP return false on initial failure */
1871 static int
1872 serviced_tcp_send(struct serviced_query* sq, sldns_buffer* buff)
1873 {
1874         int vs, rtt, timeout;
1875         uint8_t edns_lame_known;
1876         if(!infra_host(sq->outnet->infra, &sq->addr, sq->addrlen, sq->zone,
1877                 sq->zonelen, *sq->outnet->now_secs, &vs, &edns_lame_known,
1878                 &rtt))
1879                 return 0;
1880         sq->last_rtt = rtt;
1881         if(vs != -1)
1882                 sq->status = serviced_query_TCP_EDNS;
1883         else    sq->status = serviced_query_TCP;
1884         serviced_encode(sq, buff, sq->status == serviced_query_TCP_EDNS);
1885         sq->last_sent_time = *sq->outnet->now_tv;
1886         if(sq->tcp_upstream || sq->ssl_upstream) {
1887                 timeout = rtt;
1888                 if(rtt >= UNKNOWN_SERVER_NICENESS && rtt < TCP_AUTH_QUERY_TIMEOUT)
1889                         timeout = TCP_AUTH_QUERY_TIMEOUT;
1890         } else {
1891                 timeout = TCP_AUTH_QUERY_TIMEOUT;
1892         }
1893         sq->pending = pending_tcp_query(sq, buff, timeout,
1894                 serviced_tcp_callback, sq);
1895         return sq->pending != NULL;
1896 }
1897
1898 /* see if packet is edns malformed; got zeroes at start.
1899  * This is from servers that return malformed packets to EDNS0 queries,
1900  * but they return good packets for nonEDNS0 queries.
1901  * We try to detect their output; without resorting to a full parse or
1902  * check for too many bytes after the end of the packet. */
1903 static int
1904 packet_edns_malformed(struct sldns_buffer* buf, int qtype)
1905 {
1906         size_t len;
1907         if(sldns_buffer_limit(buf) < LDNS_HEADER_SIZE)
1908                 return 1; /* malformed */
1909         /* they have NOERROR rcode, 1 answer. */
1910         if(LDNS_RCODE_WIRE(sldns_buffer_begin(buf)) != LDNS_RCODE_NOERROR)
1911                 return 0;
1912         /* one query (to skip) and answer records */
1913         if(LDNS_QDCOUNT(sldns_buffer_begin(buf)) != 1 ||
1914                 LDNS_ANCOUNT(sldns_buffer_begin(buf)) == 0)
1915                 return 0;
1916         /* skip qname */
1917         len = dname_valid(sldns_buffer_at(buf, LDNS_HEADER_SIZE),
1918                 sldns_buffer_limit(buf)-LDNS_HEADER_SIZE);
1919         if(len == 0)
1920                 return 0;
1921         if(len == 1 && qtype == 0)
1922                 return 0; /* we asked for '.' and type 0 */
1923         /* and then 4 bytes (type and class of query) */
1924         if(sldns_buffer_limit(buf) < LDNS_HEADER_SIZE + len + 4 + 3)
1925                 return 0;
1926
1927         /* and start with 11 zeroes as the answer RR */
1928         /* so check the qtype of the answer record, qname=0, type=0 */
1929         if(sldns_buffer_at(buf, LDNS_HEADER_SIZE+len+4)[0] == 0 &&
1930            sldns_buffer_at(buf, LDNS_HEADER_SIZE+len+4)[1] == 0 &&
1931            sldns_buffer_at(buf, LDNS_HEADER_SIZE+len+4)[2] == 0)
1932                 return 1;
1933         return 0;
1934 }
1935
1936 int
1937 serviced_udp_callback(struct comm_point* c, void* arg, int error,
1938         struct comm_reply* rep)
1939 {
1940         struct serviced_query* sq = (struct serviced_query*)arg;
1941         struct outside_network* outnet = sq->outnet;
1942         struct timeval now = *sq->outnet->now_tv;
1943         int fallback_tcp = 0;
1944
1945         sq->pending = NULL; /* removed after callback */
1946         if(error == NETEVENT_TIMEOUT) {
1947                 int rto = 0;
1948                 if(sq->status == serviced_query_PROBE_EDNS) {
1949                         /* non-EDNS probe failed; we do not know its status,
1950                          * keep trying with EDNS, timeout may not be caused
1951                          * by EDNS. */
1952                         sq->status = serviced_query_UDP_EDNS;
1953                 }
1954                 if(sq->status == serviced_query_UDP_EDNS && sq->last_rtt < 5000) {
1955                         /* fallback to 1480/1280 */
1956                         sq->status = serviced_query_UDP_EDNS_FRAG;
1957                         log_name_addr(VERB_ALGO, "try edns1xx0", sq->qbuf+10,
1958                                 &sq->addr, sq->addrlen);
1959                         if(!serviced_udp_send(sq, c->buffer)) {
1960                                 serviced_callbacks(sq, NETEVENT_CLOSED, c, rep);
1961                         }
1962                         return 0;
1963                 }
1964                 if(sq->status == serviced_query_UDP_EDNS_FRAG) {
1965                         /* fragmentation size did not fix it */
1966                         sq->status = serviced_query_UDP_EDNS;
1967                 }
1968                 sq->retry++;
1969                 if(!(rto=infra_rtt_update(outnet->infra, &sq->addr, sq->addrlen,
1970                         sq->zone, sq->zonelen, sq->qtype, -1, sq->last_rtt,
1971                         (time_t)now.tv_sec)))
1972                         log_err("out of memory in UDP exponential backoff");
1973                 if(sq->retry < OUTBOUND_UDP_RETRY) {
1974                         log_name_addr(VERB_ALGO, "retry query", sq->qbuf+10,
1975                                 &sq->addr, sq->addrlen);
1976                         if(!serviced_udp_send(sq, c->buffer)) {
1977                                 serviced_callbacks(sq, NETEVENT_CLOSED, c, rep);
1978                         }
1979                         return 0;
1980                 }
1981                 if(rto >= RTT_MAX_TIMEOUT) {
1982                         fallback_tcp = 1;
1983                         /* UDP does not work, fallback to TCP below */
1984                 } else {
1985                         serviced_callbacks(sq, NETEVENT_TIMEOUT, c, rep);
1986                         return 0;
1987                 }
1988         } else if(error != NETEVENT_NOERROR) {
1989                 /* udp returns error (due to no ID or interface available) */
1990                 serviced_callbacks(sq, error, c, rep);
1991                 return 0;
1992         }
1993 #ifdef USE_DNSTAP
1994         if(error == NETEVENT_NOERROR && outnet->dtenv &&
1995            (outnet->dtenv->log_resolver_response_messages ||
1996             outnet->dtenv->log_forwarder_response_messages))
1997                 dt_msg_send_outside_response(outnet->dtenv, &sq->addr, c->type,
1998                 sq->zone, sq->zonelen, sq->qbuf, sq->qbuflen,
1999                 &sq->last_sent_time, sq->outnet->now_tv, c->buffer);
2000 #endif
2001         if(!fallback_tcp) {
2002             if( (sq->status == serviced_query_UDP_EDNS
2003                 ||sq->status == serviced_query_UDP_EDNS_FRAG)
2004                 && (LDNS_RCODE_WIRE(sldns_buffer_begin(c->buffer))
2005                         == LDNS_RCODE_FORMERR || LDNS_RCODE_WIRE(
2006                         sldns_buffer_begin(c->buffer)) == LDNS_RCODE_NOTIMPL
2007                     || packet_edns_malformed(c->buffer, sq->qtype)
2008                         )) {
2009                 /* try to get an answer by falling back without EDNS */
2010                 verbose(VERB_ALGO, "serviced query: attempt without EDNS");
2011                 sq->status = serviced_query_UDP_EDNS_fallback;
2012                 sq->retry = 0;
2013                 if(!serviced_udp_send(sq, c->buffer)) {
2014                         serviced_callbacks(sq, NETEVENT_CLOSED, c, rep);
2015                 }
2016                 return 0;
2017             } else if(sq->status == serviced_query_PROBE_EDNS) {
2018                 /* probe without EDNS succeeds, so we conclude that this
2019                  * host likely has EDNS packets dropped */
2020                 log_addr(VERB_DETAIL, "timeouts, concluded that connection to "
2021                         "host drops EDNS packets", &sq->addr, sq->addrlen);
2022                 /* only store noEDNS in cache if domain is noDNSSEC */
2023                 if(!sq->want_dnssec)
2024                   if(!infra_edns_update(outnet->infra, &sq->addr, sq->addrlen,
2025                         sq->zone, sq->zonelen, -1, (time_t)now.tv_sec)) {
2026                         log_err("Out of memory caching no edns for host");
2027                   }
2028                 sq->status = serviced_query_UDP;
2029             } else if(sq->status == serviced_query_UDP_EDNS &&
2030                 !sq->edns_lame_known) {
2031                 /* now we know that edns queries received answers store that */
2032                 log_addr(VERB_ALGO, "serviced query: EDNS works for",
2033                         &sq->addr, sq->addrlen);
2034                 if(!infra_edns_update(outnet->infra, &sq->addr, sq->addrlen,
2035                         sq->zone, sq->zonelen, 0, (time_t)now.tv_sec)) {
2036                         log_err("Out of memory caching edns works");
2037                 }
2038                 sq->edns_lame_known = 1;
2039             } else if(sq->status == serviced_query_UDP_EDNS_fallback &&
2040                 !sq->edns_lame_known && (LDNS_RCODE_WIRE(
2041                 sldns_buffer_begin(c->buffer)) == LDNS_RCODE_NOERROR ||
2042                 LDNS_RCODE_WIRE(sldns_buffer_begin(c->buffer)) ==
2043                 LDNS_RCODE_NXDOMAIN || LDNS_RCODE_WIRE(sldns_buffer_begin(
2044                 c->buffer)) == LDNS_RCODE_YXDOMAIN)) {
2045                 /* the fallback produced a result that looks promising, note
2046                  * that this server should be approached without EDNS */
2047                 /* only store noEDNS in cache if domain is noDNSSEC */
2048                 if(!sq->want_dnssec) {
2049                   log_addr(VERB_ALGO, "serviced query: EDNS fails for",
2050                         &sq->addr, sq->addrlen);
2051                   if(!infra_edns_update(outnet->infra, &sq->addr, sq->addrlen,
2052                         sq->zone, sq->zonelen, -1, (time_t)now.tv_sec)) {
2053                         log_err("Out of memory caching no edns for host");
2054                   }
2055                 } else {
2056                   log_addr(VERB_ALGO, "serviced query: EDNS fails, but "
2057                         "not stored because need DNSSEC for", &sq->addr,
2058                         sq->addrlen);
2059                 }
2060                 sq->status = serviced_query_UDP;
2061             }
2062             if(now.tv_sec > sq->last_sent_time.tv_sec ||
2063                 (now.tv_sec == sq->last_sent_time.tv_sec &&
2064                 now.tv_usec > sq->last_sent_time.tv_usec)) {
2065                 /* convert from microseconds to milliseconds */
2066                 int roundtime = ((int)(now.tv_sec - sq->last_sent_time.tv_sec))*1000
2067                   + ((int)now.tv_usec - (int)sq->last_sent_time.tv_usec)/1000;
2068                 verbose(VERB_ALGO, "measured roundtrip at %d msec", roundtime);
2069                 log_assert(roundtime >= 0);
2070                 /* in case the system hibernated, do not enter a huge value,
2071                  * above this value gives trouble with server selection */
2072                 if(roundtime < 60000) {
2073                     if(!infra_rtt_update(outnet->infra, &sq->addr, sq->addrlen,
2074                         sq->zone, sq->zonelen, sq->qtype, roundtime,
2075                         sq->last_rtt, (time_t)now.tv_sec))
2076                         log_err("out of memory noting rtt.");
2077                 }
2078             }
2079         } /* end of if_!fallback_tcp */
2080         /* perform TC flag check and TCP fallback after updating our
2081          * cache entries for EDNS status and RTT times */
2082         if(LDNS_TC_WIRE(sldns_buffer_begin(c->buffer)) || fallback_tcp) {
2083                 /* fallback to TCP */
2084                 /* this discards partial UDP contents */
2085                 if(sq->status == serviced_query_UDP_EDNS ||
2086                         sq->status == serviced_query_UDP_EDNS_FRAG ||
2087                         sq->status == serviced_query_UDP_EDNS_fallback)
2088                         /* if we have unfinished EDNS_fallback, start again */
2089                         sq->status = serviced_query_TCP_EDNS;
2090                 else    sq->status = serviced_query_TCP;
2091                 serviced_tcp_initiate(sq, c->buffer);
2092                 return 0;
2093         }
2094         /* yay! an answer */
2095         serviced_callbacks(sq, error, c, rep);
2096         return 0;
2097 }
2098
2099 struct serviced_query*
2100 outnet_serviced_query(struct outside_network* outnet,
2101         struct query_info* qinfo, uint16_t flags, int dnssec, int want_dnssec,
2102         int nocaps, int tcp_upstream, int ssl_upstream, char* tls_auth_name,
2103         struct sockaddr_storage* addr, socklen_t addrlen, uint8_t* zone,
2104         size_t zonelen, struct module_qstate* qstate,
2105         comm_point_callback_type* callback, void* callback_arg, sldns_buffer* buff,
2106         struct module_env* env)
2107 {
2108         struct serviced_query* sq;
2109         struct service_callback* cb;
2110         if(!inplace_cb_query_call(env, qinfo, flags, addr, addrlen, zone, zonelen,
2111                 qstate, qstate->region))
2112                         return NULL;
2113         serviced_gen_query(buff, qinfo->qname, qinfo->qname_len, qinfo->qtype,
2114                 qinfo->qclass, flags);
2115         sq = lookup_serviced(outnet, buff, dnssec, addr, addrlen,
2116                 qstate->edns_opts_back_out);
2117         /* duplicate entries are included in the callback list, because
2118          * there is a counterpart registration by our caller that needs to
2119          * be doubly-removed (with callbacks perhaps). */
2120         if(!(cb = (struct service_callback*)malloc(sizeof(*cb))))
2121                 return NULL;
2122         if(!sq) {
2123                 /* make new serviced query entry */
2124                 sq = serviced_create(outnet, buff, dnssec, want_dnssec, nocaps,
2125                         tcp_upstream, ssl_upstream, tls_auth_name, addr,
2126                         addrlen, zone, zonelen, (int)qinfo->qtype,
2127                         qstate->edns_opts_back_out);
2128                 if(!sq) {
2129                         free(cb);
2130                         return NULL;
2131                 }
2132                 /* perform first network action */
2133                 if(outnet->do_udp && !(tcp_upstream || ssl_upstream)) {
2134                         if(!serviced_udp_send(sq, buff)) {
2135                                 (void)rbtree_delete(outnet->serviced, sq);
2136                                 free(sq->qbuf);
2137                                 free(sq->zone);
2138                                 free(sq);
2139                                 free(cb);
2140                                 return NULL;
2141                         }
2142                 } else {
2143                         if(!serviced_tcp_send(sq, buff)) {
2144                                 (void)rbtree_delete(outnet->serviced, sq);
2145                                 free(sq->qbuf);
2146                                 free(sq->zone);
2147                                 free(sq);
2148                                 free(cb);
2149                                 return NULL;
2150                         }
2151                 }
2152         }
2153         /* add callback to list of callbacks */
2154         cb->cb = callback;
2155         cb->cb_arg = callback_arg;
2156         cb->next = sq->cblist;
2157         sq->cblist = cb;
2158         return sq;
2159 }
2160
2161 /** remove callback from list */
2162 static void
2163 callback_list_remove(struct serviced_query* sq, void* cb_arg)
2164 {
2165         struct service_callback** pp = &sq->cblist;
2166         while(*pp) {
2167                 if((*pp)->cb_arg == cb_arg) {
2168                         struct service_callback* del = *pp;
2169                         *pp = del->next;
2170                         free(del);
2171                         return;
2172                 }
2173                 pp = &(*pp)->next;
2174         }
2175 }
2176
2177 void outnet_serviced_query_stop(struct serviced_query* sq, void* cb_arg)
2178 {
2179         if(!sq)
2180                 return;
2181         callback_list_remove(sq, cb_arg);
2182         /* if callbacks() routine scheduled deletion, let it do that */
2183         if(!sq->cblist && !sq->to_be_deleted) {
2184                 (void)rbtree_delete(sq->outnet->serviced, sq);
2185                 serviced_delete(sq);
2186         }
2187 }
2188
2189 /** create fd to send to this destination */
2190 static int
2191 fd_for_dest(struct outside_network* outnet, struct sockaddr_storage* to_addr,
2192         socklen_t to_addrlen)
2193 {
2194         struct sockaddr_storage* addr;
2195         socklen_t addrlen;
2196         int i, try, pnum;
2197         struct port_if* pif;
2198
2199         /* create fd */
2200         for(try = 0; try<1000; try++) {
2201                 int port = 0;
2202                 int freebind = 0;
2203                 int noproto = 0;
2204                 int inuse = 0;
2205                 int fd = -1;
2206
2207                 /* select interface */
2208                 if(addr_is_ip6(to_addr, to_addrlen)) {
2209                         if(outnet->num_ip6 == 0) {
2210                                 char to[64];
2211                                 addr_to_str(to_addr, to_addrlen, to, sizeof(to));
2212                                 verbose(VERB_QUERY, "need ipv6 to send, but no ipv6 outgoing interfaces, for %s", to);
2213                                 return -1;
2214                         }
2215                         i = ub_random_max(outnet->rnd, outnet->num_ip6);
2216                         pif = &outnet->ip6_ifs[i];
2217                 } else {
2218                         if(outnet->num_ip4 == 0) {
2219                                 char to[64];
2220                                 addr_to_str(to_addr, to_addrlen, to, sizeof(to));
2221                                 verbose(VERB_QUERY, "need ipv4 to send, but no ipv4 outgoing interfaces, for %s", to);
2222                                 return -1;
2223                         }
2224                         i = ub_random_max(outnet->rnd, outnet->num_ip4);
2225                         pif = &outnet->ip4_ifs[i];
2226                 }
2227                 addr = &pif->addr;
2228                 addrlen = pif->addrlen;
2229                 pnum = ub_random_max(outnet->rnd, pif->avail_total);
2230                 if(pnum < pif->inuse) {
2231                         /* port already open */
2232                         port = pif->out[pnum]->number;
2233                 } else {
2234                         /* unused ports in start part of array */
2235                         port = pif->avail_ports[pnum - pif->inuse];
2236                 }
2237
2238                 if(addr_is_ip6(to_addr, to_addrlen)) {
2239                         struct sockaddr_in6 sa = *(struct sockaddr_in6*)addr;
2240                         sa.sin6_port = (in_port_t)htons((uint16_t)port);
2241                         fd = create_udp_sock(AF_INET6, SOCK_DGRAM,
2242                                 (struct sockaddr*)&sa, addrlen, 1, &inuse, &noproto,
2243                                 0, 0, 0, NULL, 0, freebind, 0);
2244                 } else {
2245                         struct sockaddr_in* sa = (struct sockaddr_in*)addr;
2246                         sa->sin_port = (in_port_t)htons((uint16_t)port);
2247                         fd = create_udp_sock(AF_INET, SOCK_DGRAM,
2248                                 (struct sockaddr*)addr, addrlen, 1, &inuse, &noproto,
2249                                 0, 0, 0, NULL, 0, freebind, 0);
2250                 }
2251                 if(fd != -1) {
2252                         return fd;
2253                 }
2254                 if(!inuse) {
2255                         return -1;
2256                 }
2257         }
2258         /* too many tries */
2259         log_err("cannot send probe, ports are in use");
2260         return -1;
2261 }
2262
2263 struct comm_point*
2264 outnet_comm_point_for_udp(struct outside_network* outnet,
2265         comm_point_callback_type* cb, void* cb_arg,
2266         struct sockaddr_storage* to_addr, socklen_t to_addrlen)
2267 {
2268         struct comm_point* cp;
2269         int fd = fd_for_dest(outnet, to_addr, to_addrlen);
2270         if(fd == -1) {
2271                 return NULL;
2272         }
2273         cp = comm_point_create_udp(outnet->base, fd, outnet->udp_buff,
2274                 cb, cb_arg);
2275         if(!cp) {
2276                 log_err("malloc failure");
2277                 close(fd);
2278                 return NULL;
2279         }
2280         return cp;
2281 }
2282
2283 struct comm_point*
2284 outnet_comm_point_for_tcp(struct outside_network* outnet,
2285         comm_point_callback_type* cb, void* cb_arg,
2286         struct sockaddr_storage* to_addr, socklen_t to_addrlen,
2287         sldns_buffer* query, int timeout)
2288 {
2289         struct comm_point* cp;
2290         int fd = outnet_get_tcp_fd(to_addr, to_addrlen, outnet->tcp_mss);
2291         if(fd == -1) {
2292                 return 0;
2293         }
2294         fd_set_nonblock(fd);
2295         if(!outnet_tcp_connect(fd, to_addr, to_addrlen)) {
2296                 /* outnet_tcp_connect has closed fd on error for us */
2297                 return 0;
2298         }
2299         cp = comm_point_create_tcp_out(outnet->base, 65552, cb, cb_arg);
2300         if(!cp) {
2301                 log_err("malloc failure");
2302                 close(fd);
2303                 return 0;
2304         }
2305         cp->repinfo.addrlen = to_addrlen;
2306         memcpy(&cp->repinfo.addr, to_addr, to_addrlen);
2307         /* set timeout on TCP connection */
2308         comm_point_start_listening(cp, fd, timeout);
2309         /* copy scratch buffer to cp->buffer */
2310         sldns_buffer_copy(cp->buffer, query);
2311         return cp;
2312 }
2313
2314 /** setup http request headers in buffer for sending query to destination */
2315 static int
2316 setup_http_request(sldns_buffer* buf, char* host, char* path)
2317 {
2318         sldns_buffer_clear(buf);
2319         sldns_buffer_printf(buf, "GET /%s HTTP/1.1\r\n", path);
2320         sldns_buffer_printf(buf, "Host: %s\r\n", host);
2321         sldns_buffer_printf(buf, "User-Agent: unbound/%s\r\n",
2322                 PACKAGE_VERSION);
2323         /* We do not really do multiple queries per connection,
2324          * but this header setting is also not needed.
2325          * sldns_buffer_printf(buf, "Connection: close\r\n") */
2326         sldns_buffer_printf(buf, "\r\n");
2327         if(sldns_buffer_position(buf)+10 > sldns_buffer_capacity(buf))
2328                 return 0; /* somehow buffer too short, but it is about 60K
2329                 and the request is only a couple bytes long. */
2330         sldns_buffer_flip(buf);
2331         return 1;
2332 }
2333
2334 struct comm_point*
2335 outnet_comm_point_for_http(struct outside_network* outnet,
2336         comm_point_callback_type* cb, void* cb_arg,
2337         struct sockaddr_storage* to_addr, socklen_t to_addrlen, int timeout,
2338         int ssl, char* host, char* path)
2339 {
2340         /* cp calls cb with err=NETEVENT_DONE when transfer is done */
2341         struct comm_point* cp;
2342         int fd = outnet_get_tcp_fd(to_addr, to_addrlen, outnet->tcp_mss);
2343         if(fd == -1) {
2344                 return 0;
2345         }
2346         fd_set_nonblock(fd);
2347         if(!outnet_tcp_connect(fd, to_addr, to_addrlen)) {
2348                 /* outnet_tcp_connect has closed fd on error for us */
2349                 return 0;
2350         }
2351         cp = comm_point_create_http_out(outnet->base, 65552, cb, cb_arg,
2352                 outnet->udp_buff);
2353         if(!cp) {
2354                 log_err("malloc failure");
2355                 close(fd);
2356                 return 0;
2357         }
2358         cp->repinfo.addrlen = to_addrlen;
2359         memcpy(&cp->repinfo.addr, to_addr, to_addrlen);
2360
2361         /* setup for SSL (if needed) */
2362         if(ssl) {
2363                 cp->ssl = outgoing_ssl_fd(outnet->sslctx, fd);
2364                 if(!cp->ssl) {
2365                         log_err("cannot setup https");
2366                         comm_point_delete(cp);
2367                         return NULL;
2368                 }
2369 #ifdef USE_WINSOCK
2370                 comm_point_tcp_win_bio_cb(cp, cp->ssl);
2371 #endif
2372                 cp->ssl_shake_state = comm_ssl_shake_write;
2373                 /* https verification */
2374 #ifdef HAVE_SSL_SET1_HOST
2375                 if((SSL_CTX_get_verify_mode(outnet->sslctx)&SSL_VERIFY_PEER)) {
2376                         /* because we set SSL_VERIFY_PEER, in netevent in
2377                          * ssl_handshake, it'll check if the certificate
2378                          * verification has succeeded */
2379                         /* SSL_VERIFY_PEER is set on the sslctx */
2380                         /* and the certificates to verify with are loaded into
2381                          * it with SSL_load_verify_locations or
2382                          * SSL_CTX_set_default_verify_paths */
2383                         /* setting the hostname makes openssl verify the
2384                          * host name in the x509 certificate in the
2385                          * SSL connection*/
2386                         if(!SSL_set1_host(cp->ssl, host)) {
2387                                 log_err("SSL_set1_host failed");
2388                                 comm_point_delete(cp);
2389                                 return NULL;
2390                         }
2391                 }
2392 #endif /* HAVE_SSL_SET1_HOST */
2393         }
2394
2395         /* set timeout on TCP connection */
2396         comm_point_start_listening(cp, fd, timeout);
2397
2398         /* setup http request in cp->buffer */
2399         if(!setup_http_request(cp->buffer, host, path)) {
2400                 log_err("error setting up http request");
2401                 comm_point_delete(cp);
2402                 return NULL;
2403         }
2404         return cp;
2405 }
2406
2407 /** get memory used by waiting tcp entry (in use or not) */
2408 static size_t
2409 waiting_tcp_get_mem(struct waiting_tcp* w)
2410 {
2411         size_t s;
2412         if(!w) return 0;
2413         s = sizeof(*w) + w->pkt_len;
2414         if(w->timer)
2415                 s += comm_timer_get_mem(w->timer);
2416         return s;
2417 }
2418
2419 /** get memory used by port if */
2420 static size_t
2421 if_get_mem(struct port_if* pif)
2422 {
2423         size_t s;
2424         int i;
2425         s = sizeof(*pif) + sizeof(int)*pif->avail_total +
2426                 sizeof(struct port_comm*)*pif->maxout;
2427         for(i=0; i<pif->inuse; i++)
2428                 s += sizeof(*pif->out[i]) +
2429                         comm_point_get_mem(pif->out[i]->cp);
2430         return s;
2431 }
2432
2433 /** get memory used by waiting udp */
2434 static size_t
2435 waiting_udp_get_mem(struct pending* w)
2436 {
2437         size_t s;
2438         s = sizeof(*w) + comm_timer_get_mem(w->timer) + w->pkt_len;
2439         return s;
2440 }
2441
2442 size_t outnet_get_mem(struct outside_network* outnet)
2443 {
2444         size_t i;
2445         int k;
2446         struct waiting_tcp* w;
2447         struct pending* u;
2448         struct serviced_query* sq;
2449         struct service_callback* sb;
2450         struct port_comm* pc;
2451         size_t s = sizeof(*outnet) + sizeof(*outnet->base) +
2452                 sizeof(*outnet->udp_buff) +
2453                 sldns_buffer_capacity(outnet->udp_buff);
2454         /* second buffer is not ours */
2455         for(pc = outnet->unused_fds; pc; pc = pc->next) {
2456                 s += sizeof(*pc) + comm_point_get_mem(pc->cp);
2457         }
2458         for(k=0; k<outnet->num_ip4; k++)
2459                 s += if_get_mem(&outnet->ip4_ifs[k]);
2460         for(k=0; k<outnet->num_ip6; k++)
2461                 s += if_get_mem(&outnet->ip6_ifs[k]);
2462         for(u=outnet->udp_wait_first; u; u=u->next_waiting)
2463                 s += waiting_udp_get_mem(u);
2464
2465         s += sizeof(struct pending_tcp*)*outnet->num_tcp;
2466         for(i=0; i<outnet->num_tcp; i++) {
2467                 s += sizeof(struct pending_tcp);
2468                 s += comm_point_get_mem(outnet->tcp_conns[i]->c);
2469                 if(outnet->tcp_conns[i]->query)
2470                         s += waiting_tcp_get_mem(outnet->tcp_conns[i]->query);
2471         }
2472         for(w=outnet->tcp_wait_first; w; w = w->next_waiting)
2473                 s += waiting_tcp_get_mem(w);
2474         s += sizeof(*outnet->pending);
2475         s += (sizeof(struct pending) + comm_timer_get_mem(NULL)) *
2476                 outnet->pending->count;
2477         s += sizeof(*outnet->serviced);
2478         s += outnet->svcd_overhead;
2479         RBTREE_FOR(sq, struct serviced_query*, outnet->serviced) {
2480                 s += sizeof(*sq) + sq->qbuflen;
2481                 for(sb = sq->cblist; sb; sb = sb->next)
2482                         s += sizeof(*sb);
2483         }
2484         return s;
2485 }
2486
2487 size_t
2488 serviced_get_mem(struct serviced_query* sq)
2489 {
2490         struct service_callback* sb;
2491         size_t s;
2492         s = sizeof(*sq) + sq->qbuflen;
2493         for(sb = sq->cblist; sb; sb = sb->next)
2494                 s += sizeof(*sb);
2495         if(sq->status == serviced_query_UDP_EDNS ||
2496                 sq->status == serviced_query_UDP ||
2497                 sq->status == serviced_query_PROBE_EDNS ||
2498                 sq->status == serviced_query_UDP_EDNS_FRAG ||
2499                 sq->status == serviced_query_UDP_EDNS_fallback) {
2500                 s += sizeof(struct pending);
2501                 s += comm_timer_get_mem(NULL);
2502         } else {
2503                 /* does not have size of the pkt pointer */
2504                 /* always has a timer except on malloc failures */
2505
2506                 /* these sizes are part of the main outside network mem */
2507                 /*
2508                 s += sizeof(struct waiting_tcp);
2509                 s += comm_timer_get_mem(NULL);
2510                 */
2511         }
2512         return s;
2513 }
2514