contrib/unbound/util/netevent.c

   1 /*
   2  * util/netevent.c - event notification
   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 contains event notification functions.
  40  */
  41 #include "config.h"
  42 #include "util/netevent.h"
  43 #include "util/ub_event.h"
  44 #include "util/log.h"
  45 #include "util/net_help.h"
  46 #include "util/fptr_wlist.h"
  47 #include "sldns/pkthdr.h"
  48 #include "sldns/sbuffer.h"
  49 #include "dnstap/dnstap.h"
  50 #include "dnscrypt/dnscrypt.h"
  51 #ifdef HAVE_OPENSSL_SSL_H
  52 #include <openssl/ssl.h>
  53 #endif
  54 #ifdef HAVE_OPENSSL_ERR_H
  55 #include <openssl/err.h>
  56 #endif
  57
  58 /* -------- Start of local definitions -------- */
  59 /** if CMSG_ALIGN is not defined on this platform, a workaround */
  60 #ifndef CMSG_ALIGN
  61 #  ifdef __CMSG_ALIGN
  62 #    define CMSG_ALIGN(n) __CMSG_ALIGN(n)
  63 #  elif defined(CMSG_DATA_ALIGN)
  64 #    define CMSG_ALIGN _CMSG_DATA_ALIGN
  65 #  else
  66 #    define CMSG_ALIGN(len) (((len)+sizeof(long)-1) & ~(sizeof(long)-1))
  67 #  endif
  68 #endif
  69
  70 /** if CMSG_LEN is not defined on this platform, a workaround */
  71 #ifndef CMSG_LEN
  72 #  define CMSG_LEN(len) (CMSG_ALIGN(sizeof(struct cmsghdr))+(len))
  73 #endif
  74
  75 /** if CMSG_SPACE is not defined on this platform, a workaround */
  76 #ifndef CMSG_SPACE
  77 #  ifdef _CMSG_HDR_ALIGN
  78 #    define CMSG_SPACE(l) (CMSG_ALIGN(l)+_CMSG_HDR_ALIGN(sizeof(struct cmsghdr)))
  79 #  else
  80 #    define CMSG_SPACE(l) (CMSG_ALIGN(l)+CMSG_ALIGN(sizeof(struct cmsghdr)))
  81 #  endif
  82 #endif
  83
  84 /** The TCP reading or writing query timeout in milliseconds */
  85 #define TCP_QUERY_TIMEOUT 120000
  86 /** The TCP timeout in msec for fast queries, above half are used */
  87 #define TCP_QUERY_TIMEOUT_FAST 200
  88
  89 #ifndef NONBLOCKING_IS_BROKEN
  90 /** number of UDP reads to perform per read indication from select */
  91 #define NUM_UDP_PER_SELECT 100
  92 #else
  93 #define NUM_UDP_PER_SELECT 1
  94 #endif
  95
  96 /**
  97  * The internal event structure for keeping ub_event info for the event.
  98  * Possibly other structures (list, tree) this is part of.
  99  */
 100 struct internal_event {
 101         /** the comm base */
 102         struct comm_base* base;
 103         /** ub_event event type */
 104         struct ub_event* ev;
 105 };
 106
 107 /**
 108  * Internal base structure, so that every thread has its own events.
 109  */
 110 struct internal_base {
 111         /** ub_event event_base type. */
 112         struct ub_event_base* base;
 113         /** seconds time pointer points here */
 114         time_t secs;
 115         /** timeval with current time */
 116         struct timeval now;
 117         /** the event used for slow_accept timeouts */
 118         struct ub_event* slow_accept;
 119         /** true if slow_accept is enabled */
 120         int slow_accept_enabled;
 121 };
 122
 123 /**
 124  * Internal timer structure, to store timer event in.
 125  */
 126 struct internal_timer {
 127         /** the super struct from which derived */
 128         struct comm_timer super;
 129         /** the comm base */
 130         struct comm_base* base;
 131         /** ub_event event type */
 132         struct ub_event* ev;
 133         /** is timer enabled */
 134         uint8_t enabled;
 135 };
 136
 137 /**
 138  * Internal signal structure, to store signal event in.
 139  */
 140 struct internal_signal {
 141         /** ub_event event type */
 142         struct ub_event* ev;
 143         /** next in signal list */
 144         struct internal_signal* next;
 145 };
 146
 147 /** create a tcp handler with a parent */
 148 static struct comm_point* comm_point_create_tcp_handler(
 149         struct comm_base *base, struct comm_point* parent, size_t bufsize,
 150         comm_point_callback_type* callback, void* callback_arg);
 151
 152 /* -------- End of local definitions -------- */
 153
 154 struct comm_base*
 155 comm_base_create(int sigs)
 156 {
 157         struct comm_base* b = (struct comm_base*)calloc(1,
 158                 sizeof(struct comm_base));
 159         const char *evnm="event", *evsys="", *evmethod="";
 160
 161         if(!b)
 162                 return NULL;
 163         b->eb = (struct internal_base*)calloc(1, sizeof(struct internal_base));
 164         if(!b->eb) {
 165                 free(b);
 166                 return NULL;
 167         }
 168         b->eb->base = ub_default_event_base(sigs, &b->eb->secs, &b->eb->now);
 169         if(!b->eb->base) {
 170                 free(b->eb);
 171                 free(b);
 172                 return NULL;
 173         }
 174         ub_comm_base_now(b);
 175         ub_get_event_sys(b->eb->base, &evnm, &evsys, &evmethod);
 176         verbose(VERB_ALGO, "%s %s user %s method.", evnm, evsys, evmethod);
 177         return b;
 178 }
 179
 180 struct comm_base*
 181 comm_base_create_event(struct ub_event_base* base)
 182 {
 183         struct comm_base* b = (struct comm_base*)calloc(1,
 184                 sizeof(struct comm_base));
 185         if(!b)
 186                 return NULL;
 187         b->eb = (struct internal_base*)calloc(1, sizeof(struct internal_base));
 188         if(!b->eb) {
 189                 free(b);
 190                 return NULL;
 191         }
 192         b->eb->base = base;
 193         ub_comm_base_now(b);
 194         return b;
 195 }
 196
 197 void
 198 comm_base_delete(struct comm_base* b)
 199 {
 200         if(!b)
 201                 return;
 202         if(b->eb->slow_accept_enabled) {
 203                 if(ub_event_del(b->eb->slow_accept) != 0) {
 204                         log_err("could not event_del slow_accept");
 205                 }
 206                 ub_event_free(b->eb->slow_accept);
 207         }
 208         ub_event_base_free(b->eb->base);
 209         b->eb->base = NULL;
 210         free(b->eb);
 211         free(b);
 212 }
 213
 214 void
 215 comm_base_delete_no_base(struct comm_base* b)
 216 {
 217         if(!b)
 218                 return;
 219         if(b->eb->slow_accept_enabled) {
 220                 if(ub_event_del(b->eb->slow_accept) != 0) {
 221                         log_err("could not event_del slow_accept");
 222                 }
 223                 ub_event_free(b->eb->slow_accept);
 224         }
 225         b->eb->base = NULL;
 226         free(b->eb);
 227         free(b);
 228 }
 229
 230 void
 231 comm_base_timept(struct comm_base* b, time_t** tt, struct timeval** tv)
 232 {
 233         *tt = &b->eb->secs;
 234         *tv = &b->eb->now;
 235 }
 236
 237 void
 238 comm_base_dispatch(struct comm_base* b)
 239 {
 240         int retval;
 241         retval = ub_event_base_dispatch(b->eb->base);
 242         if(retval < 0) {
 243                 fatal_exit("event_dispatch returned error %d, "
 244                         "errno is %s", retval, strerror(errno));
 245         }
 246 }
 247
 248 void comm_base_exit(struct comm_base* b)
 249 {
 250         if(ub_event_base_loopexit(b->eb->base) != 0) {
 251                 log_err("Could not loopexit");
 252         }
 253 }
 254
 255 void comm_base_set_slow_accept_handlers(struct comm_base* b,
 256         void (*stop_acc)(void*), void (*start_acc)(void*), void* arg)
 257 {
 258         b->stop_accept = stop_acc;
 259         b->start_accept = start_acc;
 260         b->cb_arg = arg;
 261 }
 262
 263 struct ub_event_base* comm_base_internal(struct comm_base* b)
 264 {
 265         return b->eb->base;
 266 }
 267
 268 /** see if errno for udp has to be logged or not uses globals */
 269 static int
 270 udp_send_errno_needs_log(struct sockaddr* addr, socklen_t addrlen)
 271 {
 272         /* do not log transient errors (unless high verbosity) */
 273 #if defined(ENETUNREACH) || defined(EHOSTDOWN) || defined(EHOSTUNREACH) || defined(ENETDOWN)
 274         switch(errno) {
 275 #  ifdef ENETUNREACH
 276                 case ENETUNREACH:
 277 #  endif
 278 #  ifdef EHOSTDOWN
 279                 case EHOSTDOWN:
 280 #  endif
 281 #  ifdef EHOSTUNREACH
 282                 case EHOSTUNREACH:
 283 #  endif
 284 #  ifdef ENETDOWN
 285                 case ENETDOWN:
 286 #  endif
 287                         if(verbosity < VERB_ALGO)
 288                                 return 0;
 289                 default:
 290                         break;
 291         }
 292 #endif
 293         /* permission denied is gotten for every send if the
 294          * network is disconnected (on some OS), squelch it */
 295         if( ((errno == EPERM)
 296 #  ifdef EADDRNOTAVAIL
 297                 /* 'Cannot assign requested address' also when disconnected */
 298                 || (errno == EADDRNOTAVAIL)
 299 #  endif
 300                 ) && verbosity < VERB_DETAIL)
 301                 return 0;
 302 #  ifdef EADDRINUSE
 303         /* If SO_REUSEADDR is set, we could try to connect to the same server
 304          * from the same source port twice. */
 305         if(errno == EADDRINUSE && verbosity < VERB_DETAIL)
 306                 return 0;
 307 #  endif
 308         /* squelch errors where people deploy AAAA ::ffff:bla for
 309          * authority servers, which we try for intranets. */
 310         if(errno == EINVAL && addr_is_ip4mapped(
 311                 (struct sockaddr_storage*)addr, addrlen) &&
 312                 verbosity < VERB_DETAIL)
 313                 return 0;
 314         /* SO_BROADCAST sockopt can give access to 255.255.255.255,
 315          * but a dns cache does not need it. */
 316         if(errno == EACCES && addr_is_broadcast(
 317                 (struct sockaddr_storage*)addr, addrlen) &&
 318                 verbosity < VERB_DETAIL)
 319                 return 0;
 320         return 1;
 321 }
 322
 323 int tcp_connect_errno_needs_log(struct sockaddr* addr, socklen_t addrlen)
 324 {
 325         return udp_send_errno_needs_log(addr, addrlen);
 326 }
 327
 328 /* send a UDP reply */
 329 int
 330 comm_point_send_udp_msg(struct comm_point *c, sldns_buffer* packet,
 331         struct sockaddr* addr, socklen_t addrlen)
 332 {
 333         ssize_t sent;
 334         log_assert(c->fd != -1);
 335 #ifdef UNBOUND_DEBUG
 336         if(sldns_buffer_remaining(packet) == 0)
 337                 log_err("error: send empty UDP packet");
 338 #endif
 339         log_assert(addr && addrlen > 0);
 340         sent = sendto(c->fd, (void*)sldns_buffer_begin(packet),
 341                 sldns_buffer_remaining(packet), 0,
 342                 addr, addrlen);
 343         if(sent == -1) {
 344                 /* try again and block, waiting for IO to complete,
 345                  * we want to send the answer, and we will wait for
 346                  * the ethernet interface buffer to have space. */
 347 #ifndef USE_WINSOCK
 348                 if(errno == EAGAIN ||
 349 #  ifdef EWOULDBLOCK
 350                         errno == EWOULDBLOCK ||
 351 #  endif
 352                         errno == ENOBUFS) {
 353 #else
 354                 if(WSAGetLastError() == WSAEINPROGRESS ||
 355                         WSAGetLastError() == WSAENOBUFS ||
 356                         WSAGetLastError() == WSAEWOULDBLOCK) {
 357 #endif
 358                         int e;
 359                         fd_set_block(c->fd);
 360                         sent = sendto(c->fd, (void*)sldns_buffer_begin(packet),
 361                                 sldns_buffer_remaining(packet), 0,
 362                                 addr, addrlen);
 363                         e = errno;
 364                         fd_set_nonblock(c->fd);
 365                         errno = e;
 366                 }
 367         }
 368         if(sent == -1) {
 369                 if(!udp_send_errno_needs_log(addr, addrlen))
 370                         return 0;
 371 #ifndef USE_WINSOCK
 372                 verbose(VERB_OPS, "sendto failed: %s", strerror(errno));
 373 #else
 374                 verbose(VERB_OPS, "sendto failed: %s",
 375                         wsa_strerror(WSAGetLastError()));
 376 #endif
 377                 log_addr(VERB_OPS, "remote address is",
 378                         (struct sockaddr_storage*)addr, addrlen);
 379                 return 0;
 380         } else if((size_t)sent != sldns_buffer_remaining(packet)) {
 381                 log_err("sent %d in place of %d bytes",
 382                         (int)sent, (int)sldns_buffer_remaining(packet));
 383                 return 0;
 384         }
 385         return 1;
 386 }
 387
 388 #if defined(AF_INET6) && defined(IPV6_PKTINFO) && (defined(HAVE_RECVMSG) || defined(HAVE_SENDMSG))
 389 /** print debug ancillary info */
 390 static void p_ancil(const char* str, struct comm_reply* r)
 391 {
 392         if(r->srctype != 4 && r->srctype != 6) {
 393                 log_info("%s: unknown srctype %d", str, r->srctype);
 394                 return;
 395         }
 396         if(r->srctype == 6) {
 397                 char buf[1024];
 398                 if(inet_ntop(AF_INET6, &r->pktinfo.v6info.ipi6_addr,
 399                         buf, (socklen_t)sizeof(buf)) == 0) {
 400                         (void)strlcpy(buf, "(inet_ntop error)", sizeof(buf));
 401                 }
 402                 buf[sizeof(buf)-1]=0;
 403                 log_info("%s: %s %d", str, buf, r->pktinfo.v6info.ipi6_ifindex);
 404         } else if(r->srctype == 4) {
 405 #ifdef IP_PKTINFO
 406                 char buf1[1024], buf2[1024];
 407                 if(inet_ntop(AF_INET, &r->pktinfo.v4info.ipi_addr,
 408                         buf1, (socklen_t)sizeof(buf1)) == 0) {
 409                         (void)strlcpy(buf1, "(inet_ntop error)", sizeof(buf1));
 410                 }
 411                 buf1[sizeof(buf1)-1]=0;
 412 #ifdef HAVE_STRUCT_IN_PKTINFO_IPI_SPEC_DST
 413                 if(inet_ntop(AF_INET, &r->pktinfo.v4info.ipi_spec_dst,
 414                         buf2, (socklen_t)sizeof(buf2)) == 0) {
 415                         (void)strlcpy(buf2, "(inet_ntop error)", sizeof(buf2));
 416                 }
 417                 buf2[sizeof(buf2)-1]=0;
 418 #else
 419                 buf2[0]=0;
 420 #endif
 421                 log_info("%s: %d %s %s", str, r->pktinfo.v4info.ipi_ifindex,
 422                         buf1, buf2);
 423 #elif defined(IP_RECVDSTADDR)
 424                 char buf1[1024];
 425                 if(inet_ntop(AF_INET, &r->pktinfo.v4addr,
 426                         buf1, (socklen_t)sizeof(buf1)) == 0) {
 427                         (void)strlcpy(buf1, "(inet_ntop error)", sizeof(buf1));
 428                 }
 429                 buf1[sizeof(buf1)-1]=0;
 430                 log_info("%s: %s", str, buf1);
 431 #endif /* IP_PKTINFO or PI_RECVDSTDADDR */
 432         }
 433 }
 434 #endif /* AF_INET6 && IPV6_PKTINFO && HAVE_RECVMSG||HAVE_SENDMSG */
 435
 436 /** send a UDP reply over specified interface*/
 437 static int
 438 comm_point_send_udp_msg_if(struct comm_point *c, sldns_buffer* packet,
 439         struct sockaddr* addr, socklen_t addrlen, struct comm_reply* r)
 440 {
 441 #if defined(AF_INET6) && defined(IPV6_PKTINFO) && defined(HAVE_SENDMSG)
 442         ssize_t sent;
 443         struct msghdr msg;
 444         struct iovec iov[1];
 445         char control[256];
 446 #ifndef S_SPLINT_S
 447         struct cmsghdr *cmsg;
 448 #endif /* S_SPLINT_S */
 449
 450         log_assert(c->fd != -1);
 451 #ifdef UNBOUND_DEBUG
 452         if(sldns_buffer_remaining(packet) == 0)
 453                 log_err("error: send empty UDP packet");
 454 #endif
 455         log_assert(addr && addrlen > 0);
 456
 457         msg.msg_name = addr;
 458         msg.msg_namelen = addrlen;
 459         iov[0].iov_base = sldns_buffer_begin(packet);
 460         iov[0].iov_len = sldns_buffer_remaining(packet);
 461         msg.msg_iov = iov;
 462         msg.msg_iovlen = 1;
 463         msg.msg_control = control;
 464 #ifndef S_SPLINT_S
 465         msg.msg_controllen = sizeof(control);
 466 #endif /* S_SPLINT_S */
 467         msg.msg_flags = 0;
 468
 469 #ifndef S_SPLINT_S
 470         cmsg = CMSG_FIRSTHDR(&msg);
 471         if(r->srctype == 4) {
 472 #ifdef IP_PKTINFO
 473                 void* cmsg_data;
 474                 msg.msg_controllen = CMSG_SPACE(sizeof(struct in_pktinfo));
 475                 log_assert(msg.msg_controllen <= sizeof(control));
 476                 cmsg->cmsg_level = IPPROTO_IP;
 477                 cmsg->cmsg_type = IP_PKTINFO;
 478                 memmove(CMSG_DATA(cmsg), &r->pktinfo.v4info,
 479                         sizeof(struct in_pktinfo));
 480                 /* unset the ifindex to not bypass the routing tables */
 481                 cmsg_data = CMSG_DATA(cmsg);
 482                 ((struct in_pktinfo *) cmsg_data)->ipi_ifindex = 0;
 483                 cmsg->cmsg_len = CMSG_LEN(sizeof(struct in_pktinfo));
 484 #elif defined(IP_SENDSRCADDR)
 485                 msg.msg_controllen = CMSG_SPACE(sizeof(struct in_addr));
 486                 log_assert(msg.msg_controllen <= sizeof(control));
 487                 cmsg->cmsg_level = IPPROTO_IP;
 488                 cmsg->cmsg_type = IP_SENDSRCADDR;
 489                 memmove(CMSG_DATA(cmsg), &r->pktinfo.v4addr,
 490                         sizeof(struct in_addr));
 491                 cmsg->cmsg_len = CMSG_LEN(sizeof(struct in_addr));
 492 #else
 493                 verbose(VERB_ALGO, "no IP_PKTINFO or IP_SENDSRCADDR");
 494                 msg.msg_control = NULL;
 495 #endif /* IP_PKTINFO or IP_SENDSRCADDR */
 496         } else if(r->srctype == 6) {
 497                 void* cmsg_data;
 498                 msg.msg_controllen = CMSG_SPACE(sizeof(struct in6_pktinfo));
 499                 log_assert(msg.msg_controllen <= sizeof(control));
 500                 cmsg->cmsg_level = IPPROTO_IPV6;
 501                 cmsg->cmsg_type = IPV6_PKTINFO;
 502                 memmove(CMSG_DATA(cmsg), &r->pktinfo.v6info,
 503                         sizeof(struct in6_pktinfo));
 504                 /* unset the ifindex to not bypass the routing tables */
 505                 cmsg_data = CMSG_DATA(cmsg);
 506                 ((struct in6_pktinfo *) cmsg_data)->ipi6_ifindex = 0;
 507                 cmsg->cmsg_len = CMSG_LEN(sizeof(struct in6_pktinfo));
 508         } else {
 509                 /* try to pass all 0 to use default route */
 510                 msg.msg_controllen = CMSG_SPACE(sizeof(struct in6_pktinfo));
 511                 log_assert(msg.msg_controllen <= sizeof(control));
 512                 cmsg->cmsg_level = IPPROTO_IPV6;
 513                 cmsg->cmsg_type = IPV6_PKTINFO;
 514                 memset(CMSG_DATA(cmsg), 0, sizeof(struct in6_pktinfo));
 515                 cmsg->cmsg_len = CMSG_LEN(sizeof(struct in6_pktinfo));
 516         }
 517 #endif /* S_SPLINT_S */
 518         if(verbosity >= VERB_ALGO)
 519                 p_ancil("send_udp over interface", r);
 520         sent = sendmsg(c->fd, &msg, 0);
 521         if(sent == -1) {
 522                 /* try again and block, waiting for IO to complete,
 523                  * we want to send the answer, and we will wait for
 524                  * the ethernet interface buffer to have space. */
 525 #ifndef USE_WINSOCK
 526                 if(errno == EAGAIN ||
 527 #  ifdef EWOULDBLOCK
 528                         errno == EWOULDBLOCK ||
 529 #  endif
 530                         errno == ENOBUFS) {
 531 #else
 532                 if(WSAGetLastError() == WSAEINPROGRESS ||
 533                         WSAGetLastError() == WSAENOBUFS ||
 534                         WSAGetLastError() == WSAEWOULDBLOCK) {
 535 #endif
 536                         int e;
 537                         fd_set_block(c->fd);
 538                         sent = sendmsg(c->fd, &msg, 0);
 539                         e = errno;
 540                         fd_set_nonblock(c->fd);
 541                         errno = e;
 542                 }
 543         }
 544         if(sent == -1) {
 545                 if(!udp_send_errno_needs_log(addr, addrlen))
 546                         return 0;
 547                 verbose(VERB_OPS, "sendmsg failed: %s", strerror(errno));
 548                 log_addr(VERB_OPS, "remote address is",
 549                         (struct sockaddr_storage*)addr, addrlen);
 550 #ifdef __NetBSD__
 551                 /* netbsd 7 has IP_PKTINFO for recv but not send */
 552                 if(errno == EINVAL && r->srctype == 4)
 553                         log_err("sendmsg: No support for sendmsg(IP_PKTINFO). "
 554                                 "Please disable interface-automatic");
 555 #endif
 556                 return 0;
 557         } else if((size_t)sent != sldns_buffer_remaining(packet)) {
 558                 log_err("sent %d in place of %d bytes",
 559                         (int)sent, (int)sldns_buffer_remaining(packet));
 560                 return 0;
 561         }
 562         return 1;
 563 #else
 564         (void)c;
 565         (void)packet;
 566         (void)addr;
 567         (void)addrlen;
 568         (void)r;
 569         log_err("sendmsg: IPV6_PKTINFO not supported");
 570         return 0;
 571 #endif /* AF_INET6 && IPV6_PKTINFO && HAVE_SENDMSG */
 572 }
 573
 574 void
 575 comm_point_udp_ancil_callback(int fd, short event, void* arg)
 576 {
 577 #if defined(AF_INET6) && defined(IPV6_PKTINFO) && defined(HAVE_RECVMSG)
 578         struct comm_reply rep;
 579         struct msghdr msg;
 580         struct iovec iov[1];
 581         ssize_t rcv;
 582         char ancil[256];
 583         int i;
 584 #ifndef S_SPLINT_S
 585         struct cmsghdr* cmsg;
 586 #endif /* S_SPLINT_S */
 587
 588         rep.c = (struct comm_point*)arg;
 589         log_assert(rep.c->type == comm_udp);
 590
 591         if(!(event&UB_EV_READ))
 592                 return;
 593         log_assert(rep.c && rep.c->buffer && rep.c->fd == fd);
 594         ub_comm_base_now(rep.c->ev->base);
 595         for(i=0; i<NUM_UDP_PER_SELECT; i++) {
 596                 sldns_buffer_clear(rep.c->buffer);
 597                 rep.addrlen = (socklen_t)sizeof(rep.addr);
 598                 log_assert(fd != -1);
 599                 log_assert(sldns_buffer_remaining(rep.c->buffer) > 0);
 600                 msg.msg_name = &rep.addr;
 601                 msg.msg_namelen = (socklen_t)sizeof(rep.addr);
 602                 iov[0].iov_base = sldns_buffer_begin(rep.c->buffer);
 603                 iov[0].iov_len = sldns_buffer_remaining(rep.c->buffer);
 604                 msg.msg_iov = iov;
 605                 msg.msg_iovlen = 1;
 606                 msg.msg_control = ancil;
 607 #ifndef S_SPLINT_S
 608                 msg.msg_controllen = sizeof(ancil);
 609 #endif /* S_SPLINT_S */
 610                 msg.msg_flags = 0;
 611                 rcv = recvmsg(fd, &msg, 0);
 612                 if(rcv == -1) {
 613                         if(errno != EAGAIN && errno != EINTR) {
 614                                 log_err("recvmsg failed: %s", strerror(errno));
 615                         }
 616                         return;
 617                 }
 618                 rep.addrlen = msg.msg_namelen;
 619                 sldns_buffer_skip(rep.c->buffer, rcv);
 620                 sldns_buffer_flip(rep.c->buffer);
 621                 rep.srctype = 0;
 622 #ifndef S_SPLINT_S
 623                 for(cmsg = CMSG_FIRSTHDR(&msg); cmsg != NULL;
 624                         cmsg = CMSG_NXTHDR(&msg, cmsg)) {
 625                         if( cmsg->cmsg_level == IPPROTO_IPV6 &&
 626                                 cmsg->cmsg_type == IPV6_PKTINFO) {
 627                                 rep.srctype = 6;
 628                                 memmove(&rep.pktinfo.v6info, CMSG_DATA(cmsg),
 629                                         sizeof(struct in6_pktinfo));
 630                                 break;
 631 #ifdef IP_PKTINFO
 632                         } else if( cmsg->cmsg_level == IPPROTO_IP &&
 633                                 cmsg->cmsg_type == IP_PKTINFO) {
 634                                 rep.srctype = 4;
 635                                 memmove(&rep.pktinfo.v4info, CMSG_DATA(cmsg),
 636                                         sizeof(struct in_pktinfo));
 637                                 break;
 638 #elif defined(IP_RECVDSTADDR)
 639                         } else if( cmsg->cmsg_level == IPPROTO_IP &&
 640                                 cmsg->cmsg_type == IP_RECVDSTADDR) {
 641                                 rep.srctype = 4;
 642                                 memmove(&rep.pktinfo.v4addr, CMSG_DATA(cmsg),
 643                                         sizeof(struct in_addr));
 644                                 break;
 645 #endif /* IP_PKTINFO or IP_RECVDSTADDR */
 646                         }
 647                 }
 648                 if(verbosity >= VERB_ALGO)
 649                         p_ancil("receive_udp on interface", &rep);
 650 #endif /* S_SPLINT_S */
 651                 fptr_ok(fptr_whitelist_comm_point(rep.c->callback));
 652                 if((*rep.c->callback)(rep.c, rep.c->cb_arg, NETEVENT_NOERROR, &rep)) {
 653                         /* send back immediate reply */
 654                         (void)comm_point_send_udp_msg_if(rep.c, rep.c->buffer,
 655                                 (struct sockaddr*)&rep.addr, rep.addrlen, &rep);
 656                 }
 657                 if(!rep.c || rep.c->fd == -1) /* commpoint closed */
 658                         break;
 659         }
 660 #else
 661         (void)fd;
 662         (void)event;
 663         (void)arg;
 664         fatal_exit("recvmsg: No support for IPV6_PKTINFO; IP_PKTINFO or IP_RECVDSTADDR. "
 665                 "Please disable interface-automatic");
 666 #endif /* AF_INET6 && IPV6_PKTINFO && HAVE_RECVMSG */
 667 }
 668
 669 void
 670 comm_point_udp_callback(int fd, short event, void* arg)
 671 {
 672         struct comm_reply rep;
 673         ssize_t rcv;
 674         int i;
 675         struct sldns_buffer *buffer;
 676
 677         rep.c = (struct comm_point*)arg;
 678         log_assert(rep.c->type == comm_udp);
 679
 680         if(!(event&UB_EV_READ))
 681                 return;
 682         log_assert(rep.c && rep.c->buffer && rep.c->fd == fd);
 683         ub_comm_base_now(rep.c->ev->base);
 684         for(i=0; i<NUM_UDP_PER_SELECT; i++) {
 685                 sldns_buffer_clear(rep.c->buffer);
 686                 rep.addrlen = (socklen_t)sizeof(rep.addr);
 687                 log_assert(fd != -1);
 688                 log_assert(sldns_buffer_remaining(rep.c->buffer) > 0);
 689                 rcv = recvfrom(fd, (void*)sldns_buffer_begin(rep.c->buffer),
 690                         sldns_buffer_remaining(rep.c->buffer), 0,
 691                         (struct sockaddr*)&rep.addr, &rep.addrlen);
 692                 if(rcv == -1) {
 693 #ifndef USE_WINSOCK
 694                         if(errno != EAGAIN && errno != EINTR)
 695                                 log_err("recvfrom %d failed: %s",
 696                                         fd, strerror(errno));
 697 #else
 698                         if(WSAGetLastError() != WSAEINPROGRESS &&
 699                                 WSAGetLastError() != WSAECONNRESET &&
 700                                 WSAGetLastError()!= WSAEWOULDBLOCK)
 701                                 log_err("recvfrom failed: %s",
 702                                         wsa_strerror(WSAGetLastError()));
 703 #endif
 704                         return;
 705                 }
 706                 sldns_buffer_skip(rep.c->buffer, rcv);
 707                 sldns_buffer_flip(rep.c->buffer);
 708                 rep.srctype = 0;
 709                 fptr_ok(fptr_whitelist_comm_point(rep.c->callback));
 710                 if((*rep.c->callback)(rep.c, rep.c->cb_arg, NETEVENT_NOERROR, &rep)) {
 711                         /* send back immediate reply */
 712 #ifdef USE_DNSCRYPT
 713                         buffer = rep.c->dnscrypt_buffer;
 714 #else
 715                         buffer = rep.c->buffer;
 716 #endif
 717                         (void)comm_point_send_udp_msg(rep.c, buffer,
 718                                 (struct sockaddr*)&rep.addr, rep.addrlen);
 719                 }
 720                 if(!rep.c || rep.c->fd != fd) /* commpoint closed to -1 or reused for
 721                 another UDP port. Note rep.c cannot be reused with TCP fd. */
 722                         break;
 723         }
 724 }
 725
 726 /** Use a new tcp handler for new query fd, set to read query */
 727 static void
 728 setup_tcp_handler(struct comm_point* c, int fd, int cur, int max)
 729 {
 730         log_assert(c->type == comm_tcp);
 731         log_assert(c->fd == -1);
 732         sldns_buffer_clear(c->buffer);
 733 #ifdef USE_DNSCRYPT
 734         if (c->dnscrypt)
 735                 sldns_buffer_clear(c->dnscrypt_buffer);
 736 #endif
 737         c->tcp_is_reading = 1;
 738         c->tcp_byte_count = 0;
 739         c->tcp_timeout_msec = TCP_QUERY_TIMEOUT;
 740         /* if more than half the tcp handlers are in use, use a shorter
 741          * timeout for this TCP connection, we need to make space for
 742          * other connections to be able to get attention */
 743         if(cur > max/2)
 744                 c->tcp_timeout_msec = TCP_QUERY_TIMEOUT_FAST;
 745         comm_point_start_listening(c, fd, c->tcp_timeout_msec);
 746 }
 747
 748 void comm_base_handle_slow_accept(int ATTR_UNUSED(fd),
 749         short ATTR_UNUSED(event), void* arg)
 750 {
 751         struct comm_base* b = (struct comm_base*)arg;
 752         /* timeout for the slow accept, re-enable accepts again */
 753         if(b->start_accept) {
 754                 verbose(VERB_ALGO, "wait is over, slow accept disabled");
 755                 fptr_ok(fptr_whitelist_start_accept(b->start_accept));
 756                 (*b->start_accept)(b->cb_arg);
 757                 b->eb->slow_accept_enabled = 0;
 758         }
 759 }
 760
 761 int comm_point_perform_accept(struct comm_point* c,
 762         struct sockaddr_storage* addr, socklen_t* addrlen)
 763 {
 764         int new_fd;
 765         *addrlen = (socklen_t)sizeof(*addr);
 766         new_fd = accept(c->fd, (struct sockaddr*)addr, addrlen);
 767         if(new_fd == -1) {
 768 #ifndef USE_WINSOCK
 769                 /* EINTR is signal interrupt. others are closed connection. */
 770                 if(     errno == EINTR || errno == EAGAIN
 771 #ifdef EWOULDBLOCK
 772                         || errno == EWOULDBLOCK
 773 #endif
 774 #ifdef ECONNABORTED
 775                         || errno == ECONNABORTED
 776 #endif
 777 #ifdef EPROTO
 778                         || errno == EPROTO
 779 #endif /* EPROTO */
 780                         )
 781                         return -1;
 782 #if defined(ENFILE) && defined(EMFILE)
 783                 if(errno == ENFILE || errno == EMFILE) {
 784                         /* out of file descriptors, likely outside of our
 785                          * control. stop accept() calls for some time */
 786                         if(c->ev->base->stop_accept) {
 787                                 struct comm_base* b = c->ev->base;
 788                                 struct timeval tv;
 789                                 verbose(VERB_ALGO, "out of file descriptors: "
 790                                         "slow accept");
 791                                 b->eb->slow_accept_enabled = 1;
 792                                 fptr_ok(fptr_whitelist_stop_accept(
 793                                         b->stop_accept));
 794                                 (*b->stop_accept)(b->cb_arg);
 795                                 /* set timeout, no mallocs */
 796                                 tv.tv_sec = NETEVENT_SLOW_ACCEPT_TIME/1000;
 797                                 tv.tv_usec = (NETEVENT_SLOW_ACCEPT_TIME%1000)*1000;
 798                                 b->eb->slow_accept = ub_event_new(b->eb->base,
 799                                         -1, UB_EV_TIMEOUT,
 800                                         comm_base_handle_slow_accept, b);
 801                                 if(b->eb->slow_accept == NULL) {
 802                                         /* we do not want to log here, because
 803                                          * that would spam the logfiles.
 804                                          * error: "event_base_set failed." */
 805                                 }
 806                                 else if(ub_event_add(b->eb->slow_accept, &tv)
 807                                         != 0) {
 808                                         /* we do not want to log here,
 809                                          * error: "event_add failed." */
 810                                 }
 811                         }
 812                         return -1;
 813                 }
 814 #endif
 815                 log_err_addr("accept failed", strerror(errno), addr, *addrlen);
 816 #else /* USE_WINSOCK */
 817                 if(WSAGetLastError() == WSAEINPROGRESS ||
 818                         WSAGetLastError() == WSAECONNRESET)
 819                         return -1;
 820                 if(WSAGetLastError() == WSAEWOULDBLOCK) {
 821                         ub_winsock_tcp_wouldblock(c->ev->ev, UB_EV_READ);
 822                         return -1;
 823                 }
 824                 log_err_addr("accept failed", wsa_strerror(WSAGetLastError()),
 825                         addr, *addrlen);
 826 #endif
 827                 return -1;
 828         }
 829         fd_set_nonblock(new_fd);
 830         return new_fd;
 831 }
 832
 833 #ifdef USE_WINSOCK
 834 static long win_bio_cb(BIO *b, int oper, const char* ATTR_UNUSED(argp),
 835         int ATTR_UNUSED(argi), long argl, long retvalue)
 836 {
 837         verbose(VERB_ALGO, "bio_cb %d, %s %s %s", oper,
 838                 (oper&BIO_CB_RETURN)?"return":"before",
 839                 (oper&BIO_CB_READ)?"read":((oper&BIO_CB_WRITE)?"write":"other"),
 840                 WSAGetLastError()==WSAEWOULDBLOCK?"wsawb":"");
 841         /* on windows, check if previous operation caused EWOULDBLOCK */
 842         if( (oper == (BIO_CB_READ|BIO_CB_RETURN) && argl == 0) ||
 843                 (oper == (BIO_CB_GETS|BIO_CB_RETURN) && argl == 0)) {
 844                 if(WSAGetLastError() == WSAEWOULDBLOCK)
 845                         ub_winsock_tcp_wouldblock((struct ub_event*)
 846                                 BIO_get_callback_arg(b), UB_EV_READ);
 847         }
 848         if( (oper == (BIO_CB_WRITE|BIO_CB_RETURN) && argl == 0) ||
 849                 (oper == (BIO_CB_PUTS|BIO_CB_RETURN) && argl == 0)) {
 850                 if(WSAGetLastError() == WSAEWOULDBLOCK)
 851                         ub_winsock_tcp_wouldblock((struct ub_event*)
 852                                 BIO_get_callback_arg(b), UB_EV_WRITE);
 853         }
 854         /* return original return value */
 855         return retvalue;
 856 }
 857
 858 /** set win bio callbacks for nonblocking operations */
 859 void
 860 comm_point_tcp_win_bio_cb(struct comm_point* c, void* thessl)
 861 {
 862         SSL* ssl = (SSL*)thessl;
 863         /* set them both just in case, but usually they are the same BIO */
 864         BIO_set_callback(SSL_get_rbio(ssl), &win_bio_cb);
 865         BIO_set_callback_arg(SSL_get_rbio(ssl), (char*)c->ev->ev);
 866         BIO_set_callback(SSL_get_wbio(ssl), &win_bio_cb);
 867         BIO_set_callback_arg(SSL_get_wbio(ssl), (char*)c->ev->ev);
 868 }
 869 #endif
 870
 871 void
 872 comm_point_tcp_accept_callback(int fd, short event, void* arg)
 873 {
 874         struct comm_point* c = (struct comm_point*)arg, *c_hdl;
 875         int new_fd;
 876         log_assert(c->type == comm_tcp_accept);
 877         if(!(event & UB_EV_READ)) {
 878                 log_info("ignoring tcp accept event %d", (int)event);
 879                 return;
 880         }
 881         ub_comm_base_now(c->ev->base);
 882         /* find free tcp handler. */
 883         if(!c->tcp_free) {
 884                 log_warn("accepted too many tcp, connections full");
 885                 return;
 886         }
 887         /* accept incoming connection. */
 888         c_hdl = c->tcp_free;
 889         log_assert(fd != -1);
 890         (void)fd;
 891         new_fd = comm_point_perform_accept(c, &c_hdl->repinfo.addr,
 892                 &c_hdl->repinfo.addrlen);
 893         if(new_fd == -1)
 894                 return;
 895         if(c->ssl) {
 896                 c_hdl->ssl = incoming_ssl_fd(c->ssl, new_fd);
 897                 if(!c_hdl->ssl) {
 898                         c_hdl->fd = new_fd;
 899                         comm_point_close(c_hdl);
 900                         return;
 901                 }
 902                 c_hdl->ssl_shake_state = comm_ssl_shake_read;
 903 #ifdef USE_WINSOCK
 904                 comm_point_tcp_win_bio_cb(c_hdl, c_hdl->ssl);
 905 #endif
 906         }
 907
 908         /* grab the tcp handler buffers */
 909         c->cur_tcp_count++;
 910         c->tcp_free = c_hdl->tcp_free;
 911         if(!c->tcp_free) {
 912                 /* stop accepting incoming queries for now. */
 913                 comm_point_stop_listening(c);
 914         }
 915         setup_tcp_handler(c_hdl, new_fd, c->cur_tcp_count, c->max_tcp_count);
 916 }
 917
 918 /** Make tcp handler free for next assignment */
 919 static void
 920 reclaim_tcp_handler(struct comm_point* c)
 921 {
 922         log_assert(c->type == comm_tcp);
 923         if(c->ssl) {
 924 #ifdef HAVE_SSL
 925                 SSL_shutdown(c->ssl);
 926                 SSL_free(c->ssl);
 927                 c->ssl = NULL;
 928 #endif
 929         }
 930         comm_point_close(c);
 931         if(c->tcp_parent) {
 932                 c->tcp_parent->cur_tcp_count--;
 933                 c->tcp_free = c->tcp_parent->tcp_free;
 934                 c->tcp_parent->tcp_free = c;
 935                 if(!c->tcp_free) {
 936                         /* re-enable listening on accept socket */
 937                         comm_point_start_listening(c->tcp_parent, -1, -1);
 938                 }
 939         }
 940 }
 941
 942 /** do the callback when writing is done */
 943 static void
 944 tcp_callback_writer(struct comm_point* c)
 945 {
 946         log_assert(c->type == comm_tcp);
 947         sldns_buffer_clear(c->buffer);
 948         if(c->tcp_do_toggle_rw)
 949                 c->tcp_is_reading = 1;
 950         c->tcp_byte_count = 0;
 951         /* switch from listening(write) to listening(read) */
 952         comm_point_stop_listening(c);
 953         comm_point_start_listening(c, -1, -1);
 954 }
 955
 956 /** do the callback when reading is done */
 957 static void
 958 tcp_callback_reader(struct comm_point* c)
 959 {
 960         log_assert(c->type == comm_tcp || c->type == comm_local);
 961         sldns_buffer_flip(c->buffer);
 962         if(c->tcp_do_toggle_rw)
 963                 c->tcp_is_reading = 0;
 964         c->tcp_byte_count = 0;
 965         if(c->type == comm_tcp)
 966                 comm_point_stop_listening(c);
 967         fptr_ok(fptr_whitelist_comm_point(c->callback));
 968         if( (*c->callback)(c, c->cb_arg, NETEVENT_NOERROR, &c->repinfo) ) {
 969                 comm_point_start_listening(c, -1, c->tcp_timeout_msec);
 970         }
 971 }
 972
 973 #ifdef HAVE_SSL
 974 /** log certificate details */
 975 static void
 976 log_cert(unsigned level, const char* str, X509* cert)
 977 {
 978         BIO* bio;
 979         char nul = 0;
 980         char* pp = NULL;
 981         long len;
 982         if(verbosity < level) return;
 983         bio = BIO_new(BIO_s_mem());
 984         if(!bio) return;
 985         X509_print_ex(bio, cert, 0, (unsigned long)-1
 986                 ^(X509_FLAG_NO_SUBJECT
 987                         |X509_FLAG_NO_ISSUER|X509_FLAG_NO_VALIDITY
 988                         |X509_FLAG_NO_EXTENSIONS|X509_FLAG_NO_AUX
 989                         |X509_FLAG_NO_ATTRIBUTES));
 990         BIO_write(bio, &nul, (int)sizeof(nul));
 991         len = BIO_get_mem_data(bio, &pp);
 992         if(len != 0 && pp) {
 993                 verbose(level, "%s: \n%s", str, pp);
 994         }
 995         BIO_free(bio);
 996 }
 997 #endif /* HAVE_SSL */
 998
 999 /** continue ssl handshake */
1000 #ifdef HAVE_SSL
1001 static int
1002 ssl_handshake(struct comm_point* c)
1003 {
1004         int r;
1005         if(c->ssl_shake_state == comm_ssl_shake_hs_read) {
1006                 /* read condition satisfied back to writing */
1007                 comm_point_listen_for_rw(c, 1, 1);
1008                 c->ssl_shake_state = comm_ssl_shake_none;
1009                 return 1;
1010         }
1011         if(c->ssl_shake_state == comm_ssl_shake_hs_write) {
1012                 /* write condition satisfied, back to reading */
1013                 comm_point_listen_for_rw(c, 1, 0);
1014                 c->ssl_shake_state = comm_ssl_shake_none;
1015                 return 1;
1016         }
1017
1018         ERR_clear_error();
1019         r = SSL_do_handshake(c->ssl);
1020         if(r != 1) {
1021                 int want = SSL_get_error(c->ssl, r);
1022                 if(want == SSL_ERROR_WANT_READ) {
1023                         if(c->ssl_shake_state == comm_ssl_shake_read)
1024                                 return 1;
1025                         c->ssl_shake_state = comm_ssl_shake_read;
1026                         comm_point_listen_for_rw(c, 1, 0);
1027                         return 1;
1028                 } else if(want == SSL_ERROR_WANT_WRITE) {
1029                         if(c->ssl_shake_state == comm_ssl_shake_write)
1030                                 return 1;
1031                         c->ssl_shake_state = comm_ssl_shake_write;
1032                         comm_point_listen_for_rw(c, 0, 1);
1033                         return 1;
1034                 } else if(r == 0) {
1035                         return 0; /* closed */
1036                 } else if(want == SSL_ERROR_SYSCALL) {
1037                         /* SYSCALL and errno==0 means closed uncleanly */
1038                         if(errno != 0)
1039                                 log_err("SSL_handshake syscall: %s",
1040                                         strerror(errno));
1041                         return 0;
1042                 } else {
1043                         log_crypto_err("ssl handshake failed");
1044                         log_addr(1, "ssl handshake failed", &c->repinfo.addr,
1045                                 c->repinfo.addrlen);
1046                         return 0;
1047                 }
1048         }
1049         /* this is where peer verification could take place */
1050         if((SSL_get_verify_mode(c->ssl)&SSL_VERIFY_PEER)) {
1051                 /* verification */
1052                 if(SSL_get_verify_result(c->ssl) == X509_V_OK) {
1053                         X509* x = SSL_get_peer_certificate(c->ssl);
1054                         if(!x) {
1055                                 log_addr(VERB_ALGO, "SSL connection failed: "
1056                                         "no certificate",
1057                                         &c->repinfo.addr, c->repinfo.addrlen);
1058                                 return 0;
1059                         }
1060                         log_cert(VERB_ALGO, "peer certificate", x);
1061 #ifdef HAVE_SSL_GET0_PEERNAME
1062                         if(SSL_get0_peername(c->ssl)) {
1063                                 char buf[255];
1064                                 snprintf(buf, sizeof(buf), "SSL connection "
1065                                         "to %s authenticated",
1066                                         SSL_get0_peername(c->ssl));
1067                                 log_addr(VERB_ALGO, buf, &c->repinfo.addr,
1068                                         c->repinfo.addrlen);
1069                         } else {
1070 #endif
1071                                 log_addr(VERB_ALGO, "SSL connection "
1072                                         "authenticated", &c->repinfo.addr,
1073                                         c->repinfo.addrlen);
1074 #ifdef HAVE_SSL_GET0_PEERNAME
1075                         }
1076 #endif
1077                         X509_free(x);
1078                 } else {
1079                         X509* x = SSL_get_peer_certificate(c->ssl);
1080                         if(x) {
1081                                 log_cert(VERB_ALGO, "peer certificate", x);
1082                                 X509_free(x);
1083                         }
1084                         log_addr(VERB_ALGO, "SSL connection failed: "
1085                                 "failed to authenticate",
1086                                 &c->repinfo.addr, c->repinfo.addrlen);
1087                         return 0;
1088                 }
1089         } else {
1090                 /* unauthenticated, the verify peer flag was not set
1091                  * in c->ssl when the ssl object was created from ssl_ctx */
1092                 log_addr(VERB_ALGO, "SSL connection", &c->repinfo.addr,
1093                         c->repinfo.addrlen);
1094         }
1095
1096         /* setup listen rw correctly */
1097         if(c->tcp_is_reading) {
1098                 if(c->ssl_shake_state != comm_ssl_shake_read)
1099                         comm_point_listen_for_rw(c, 1, 0);
1100         } else {
1101                 comm_point_listen_for_rw(c, 1, 1);
1102         }
1103         c->ssl_shake_state = comm_ssl_shake_none;
1104         return 1;
1105 }
1106 #endif /* HAVE_SSL */
1107
1108 /** ssl read callback on TCP */
1109 static int
1110 ssl_handle_read(struct comm_point* c)
1111 {
1112 #ifdef HAVE_SSL
1113         int r;
1114         if(c->ssl_shake_state != comm_ssl_shake_none) {
1115                 if(!ssl_handshake(c))
1116                         return 0;
1117                 if(c->ssl_shake_state != comm_ssl_shake_none)
1118                         return 1;
1119         }
1120         if(c->tcp_byte_count < sizeof(uint16_t)) {
1121                 /* read length bytes */
1122                 ERR_clear_error();
1123                 if((r=SSL_read(c->ssl, (void*)sldns_buffer_at(c->buffer,
1124                         c->tcp_byte_count), (int)(sizeof(uint16_t) -
1125                         c->tcp_byte_count))) <= 0) {
1126                         int want = SSL_get_error(c->ssl, r);
1127                         if(want == SSL_ERROR_ZERO_RETURN) {
1128                                 return 0; /* shutdown, closed */
1129                         } else if(want == SSL_ERROR_WANT_READ) {
1130                                 return 1; /* read more later */
1131                         } else if(want == SSL_ERROR_WANT_WRITE) {
1132                                 c->ssl_shake_state = comm_ssl_shake_hs_write;
1133                                 comm_point_listen_for_rw(c, 0, 1);
1134                                 return 1;
1135                         } else if(want == SSL_ERROR_SYSCALL) {
1136                                 if(errno != 0)
1137                                         log_err("SSL_read syscall: %s",
1138                                                 strerror(errno));
1139                                 return 0;
1140                         }
1141                         log_crypto_err("could not SSL_read");
1142                         return 0;
1143                 }
1144                 c->tcp_byte_count += r;
1145                 if(c->tcp_byte_count != sizeof(uint16_t))
1146                         return 1;
1147                 if(sldns_buffer_read_u16_at(c->buffer, 0) >
1148                         sldns_buffer_capacity(c->buffer)) {
1149                         verbose(VERB_QUERY, "ssl: dropped larger than buffer");
1150                         return 0;
1151                 }
1152                 sldns_buffer_set_limit(c->buffer,
1153                         sldns_buffer_read_u16_at(c->buffer, 0));
1154                 if(sldns_buffer_limit(c->buffer) < LDNS_HEADER_SIZE) {
1155                         verbose(VERB_QUERY, "ssl: dropped bogus too short.");
1156                         return 0;
1157                 }
1158                 verbose(VERB_ALGO, "Reading ssl tcp query of length %d",
1159                         (int)sldns_buffer_limit(c->buffer));
1160         }
1161         log_assert(sldns_buffer_remaining(c->buffer) > 0);
1162         ERR_clear_error();
1163         r = SSL_read(c->ssl, (void*)sldns_buffer_current(c->buffer),
1164                 (int)sldns_buffer_remaining(c->buffer));
1165         if(r <= 0) {
1166                 int want = SSL_get_error(c->ssl, r);
1167                 if(want == SSL_ERROR_ZERO_RETURN) {
1168                         return 0; /* shutdown, closed */
1169                 } else if(want == SSL_ERROR_WANT_READ) {
1170                         return 1; /* read more later */
1171                 } else if(want == SSL_ERROR_WANT_WRITE) {
1172                         c->ssl_shake_state = comm_ssl_shake_hs_write;
1173                         comm_point_listen_for_rw(c, 0, 1);
1174                         return 1;
1175                 } else if(want == SSL_ERROR_SYSCALL) {
1176                         if(errno != 0)
1177                                 log_err("SSL_read syscall: %s",
1178                                         strerror(errno));
1179                         return 0;
1180                 }
1181                 log_crypto_err("could not SSL_read");
1182                 return 0;
1183         }
1184         sldns_buffer_skip(c->buffer, (ssize_t)r);
1185         if(sldns_buffer_remaining(c->buffer) <= 0) {
1186                 tcp_callback_reader(c);
1187         }
1188         return 1;
1189 #else
1190         (void)c;
1191         return 0;
1192 #endif /* HAVE_SSL */
1193 }
1194
1195 /** ssl write callback on TCP */
1196 static int
1197 ssl_handle_write(struct comm_point* c)
1198 {
1199 #ifdef HAVE_SSL
1200         int r;
1201         if(c->ssl_shake_state != comm_ssl_shake_none) {
1202                 if(!ssl_handshake(c))
1203                         return 0;
1204                 if(c->ssl_shake_state != comm_ssl_shake_none)
1205                         return 1;
1206         }
1207         /* ignore return, if fails we may simply block */
1208         (void)SSL_set_mode(c->ssl, SSL_MODE_ENABLE_PARTIAL_WRITE);
1209         if(c->tcp_byte_count < sizeof(uint16_t)) {
1210                 uint16_t len = htons(sldns_buffer_limit(c->buffer));
1211                 ERR_clear_error();
1212                 r = SSL_write(c->ssl,
1213                         (void*)(((uint8_t*)&len)+c->tcp_byte_count),
1214                         (int)(sizeof(uint16_t)-c->tcp_byte_count));
1215                 if(r <= 0) {
1216                         int want = SSL_get_error(c->ssl, r);
1217                         if(want == SSL_ERROR_ZERO_RETURN) {
1218                                 return 0; /* closed */
1219                         } else if(want == SSL_ERROR_WANT_READ) {
1220                                 c->ssl_shake_state = comm_ssl_shake_read;
1221                                 comm_point_listen_for_rw(c, 1, 0);
1222                                 return 1; /* wait for read condition */
1223                         } else if(want == SSL_ERROR_WANT_WRITE) {
1224                                 return 1; /* write more later */
1225                         } else if(want == SSL_ERROR_SYSCALL) {
1226                                 if(errno != 0)
1227                                         log_err("SSL_write syscall: %s",
1228                                                 strerror(errno));
1229                                 return 0;
1230                         }
1231                         log_crypto_err("could not SSL_write");
1232                         return 0;
1233                 }
1234                 c->tcp_byte_count += r;
1235                 if(c->tcp_byte_count < sizeof(uint16_t))
1236                         return 1;
1237                 sldns_buffer_set_position(c->buffer, c->tcp_byte_count -
1238                         sizeof(uint16_t));
1239                 if(sldns_buffer_remaining(c->buffer) == 0) {
1240                         tcp_callback_writer(c);
1241                         return 1;
1242                 }
1243         }
1244         log_assert(sldns_buffer_remaining(c->buffer) > 0);
1245         ERR_clear_error();
1246         r = SSL_write(c->ssl, (void*)sldns_buffer_current(c->buffer),
1247                 (int)sldns_buffer_remaining(c->buffer));
1248         if(r <= 0) {
1249                 int want = SSL_get_error(c->ssl, r);
1250                 if(want == SSL_ERROR_ZERO_RETURN) {
1251                         return 0; /* closed */
1252                 } else if(want == SSL_ERROR_WANT_READ) {
1253                         c->ssl_shake_state = comm_ssl_shake_read;
1254                         comm_point_listen_for_rw(c, 1, 0);
1255                         return 1; /* wait for read condition */
1256                 } else if(want == SSL_ERROR_WANT_WRITE) {
1257                         return 1; /* write more later */
1258                 } else if(want == SSL_ERROR_SYSCALL) {
1259                         if(errno != 0)
1260                                 log_err("SSL_write syscall: %s",
1261                                         strerror(errno));
1262                         return 0;
1263                 }
1264                 log_crypto_err("could not SSL_write");
1265                 return 0;
1266         }
1267         sldns_buffer_skip(c->buffer, (ssize_t)r);
1268
1269         if(sldns_buffer_remaining(c->buffer) == 0) {
1270                 tcp_callback_writer(c);
1271         }
1272         return 1;
1273 #else
1274         (void)c;
1275         return 0;
1276 #endif /* HAVE_SSL */
1277 }
1278
1279 /** handle ssl tcp connection with dns contents */
1280 static int
1281 ssl_handle_it(struct comm_point* c)
1282 {
1283         if(c->tcp_is_reading)
1284                 return ssl_handle_read(c);
1285         return ssl_handle_write(c);
1286 }
1287
1288 /** Handle tcp reading callback.
1289  * @param fd: file descriptor of socket.
1290  * @param c: comm point to read from into buffer.
1291  * @param short_ok: if true, very short packets are OK (for comm_local).
1292  * @return: 0 on error
1293  */
1294 static int
1295 comm_point_tcp_handle_read(int fd, struct comm_point* c, int short_ok)
1296 {
1297         ssize_t r;
1298         log_assert(c->type == comm_tcp || c->type == comm_local);
1299         if(c->ssl)
1300                 return ssl_handle_it(c);
1301         if(!c->tcp_is_reading)
1302                 return 0;
1303
1304         log_assert(fd != -1);
1305         if(c->tcp_byte_count < sizeof(uint16_t)) {
1306                 /* read length bytes */
1307                 r = recv(fd,(void*)sldns_buffer_at(c->buffer,c->tcp_byte_count),
1308                         sizeof(uint16_t)-c->tcp_byte_count, 0);
1309                 if(r == 0)
1310                         return 0;
1311                 else if(r == -1) {
1312 #ifndef USE_WINSOCK
1313                         if(errno == EINTR || errno == EAGAIN)
1314                                 return 1;
1315 #ifdef ECONNRESET
1316                         if(errno == ECONNRESET && verbosity < 2)
1317                                 return 0; /* silence reset by peer */
1318 #endif
1319                         log_err_addr("read (in tcp s)", strerror(errno),
1320                                 &c->repinfo.addr, c->repinfo.addrlen);
1321 #else /* USE_WINSOCK */
1322                         if(WSAGetLastError() == WSAECONNRESET)
1323                                 return 0;
1324                         if(WSAGetLastError() == WSAEINPROGRESS)
1325                                 return 1;
1326                         if(WSAGetLastError() == WSAEWOULDBLOCK) {
1327                                 ub_winsock_tcp_wouldblock(c->ev->ev,
1328                                         UB_EV_READ);
1329                                 return 1;
1330                         }
1331                         log_err_addr("read (in tcp s)",
1332                                 wsa_strerror(WSAGetLastError()),
1333                                 &c->repinfo.addr, c->repinfo.addrlen);
1334 #endif
1335                         return 0;
1336                 }
1337                 c->tcp_byte_count += r;
1338                 if(c->tcp_byte_count != sizeof(uint16_t))
1339                         return 1;
1340                 if(sldns_buffer_read_u16_at(c->buffer, 0) >
1341                         sldns_buffer_capacity(c->buffer)) {
1342                         verbose(VERB_QUERY, "tcp: dropped larger than buffer");
1343                         return 0;
1344                 }
1345                 sldns_buffer_set_limit(c->buffer,
1346                         sldns_buffer_read_u16_at(c->buffer, 0));
1347                 if(!short_ok &&
1348                         sldns_buffer_limit(c->buffer) < LDNS_HEADER_SIZE) {
1349                         verbose(VERB_QUERY, "tcp: dropped bogus too short.");
1350                         return 0;
1351                 }
1352                 verbose(VERB_ALGO, "Reading tcp query of length %d",
1353                         (int)sldns_buffer_limit(c->buffer));
1354         }
1355
1356         log_assert(sldns_buffer_remaining(c->buffer) > 0);
1357         r = recv(fd, (void*)sldns_buffer_current(c->buffer),
1358                 sldns_buffer_remaining(c->buffer), 0);
1359         if(r == 0) {
1360                 return 0;
1361         } else if(r == -1) {
1362 #ifndef USE_WINSOCK
1363                 if(errno == EINTR || errno == EAGAIN)
1364                         return 1;
1365                 log_err_addr("read (in tcp r)", strerror(errno),
1366                         &c->repinfo.addr, c->repinfo.addrlen);
1367 #else /* USE_WINSOCK */
1368                 if(WSAGetLastError() == WSAECONNRESET)
1369                         return 0;
1370                 if(WSAGetLastError() == WSAEINPROGRESS)
1371                         return 1;
1372                 if(WSAGetLastError() == WSAEWOULDBLOCK) {
1373                         ub_winsock_tcp_wouldblock(c->ev->ev, UB_EV_READ);
1374                         return 1;
1375                 }
1376                 log_err_addr("read (in tcp r)",
1377                         wsa_strerror(WSAGetLastError()),
1378                         &c->repinfo.addr, c->repinfo.addrlen);
1379 #endif
1380                 return 0;
1381         }
1382         sldns_buffer_skip(c->buffer, r);
1383         if(sldns_buffer_remaining(c->buffer) <= 0) {
1384                 tcp_callback_reader(c);
1385         }
1386         return 1;
1387 }
1388
1389 /**
1390  * Handle tcp writing callback.
1391  * @param fd: file descriptor of socket.
1392  * @param c: comm point to write buffer out of.
1393  * @return: 0 on error
1394  */
1395 static int
1396 comm_point_tcp_handle_write(int fd, struct comm_point* c)
1397 {
1398         ssize_t r;
1399         struct sldns_buffer *buffer;
1400         log_assert(c->type == comm_tcp);
1401 #ifdef USE_DNSCRYPT
1402         buffer = c->dnscrypt_buffer;
1403 #else
1404         buffer = c->buffer;
1405 #endif
1406         if(c->tcp_is_reading && !c->ssl)
1407                 return 0;
1408         log_assert(fd != -1);
1409         if(c->tcp_byte_count == 0 && c->tcp_check_nb_connect) {
1410                 /* check for pending error from nonblocking connect */
1411                 /* from Stevens, unix network programming, vol1, 3rd ed, p450*/
1412                 int error = 0;
1413                 socklen_t len = (socklen_t)sizeof(error);
1414                 if(getsockopt(fd, SOL_SOCKET, SO_ERROR, (void*)&error,
1415                         &len) < 0){
1416 #ifndef USE_WINSOCK
1417                         error = errno; /* on solaris errno is error */
1418 #else /* USE_WINSOCK */
1419                         error = WSAGetLastError();
1420 #endif
1421                 }
1422 #ifndef USE_WINSOCK
1423 #if defined(EINPROGRESS) && defined(EWOULDBLOCK)
1424                 if(error == EINPROGRESS || error == EWOULDBLOCK)
1425                         return 1; /* try again later */
1426                 else
1427 #endif
1428                 if(error != 0 && verbosity < 2)
1429                         return 0; /* silence lots of chatter in the logs */
1430                 else if(error != 0) {
1431                         log_err_addr("tcp connect", strerror(error),
1432                                 &c->repinfo.addr, c->repinfo.addrlen);
1433 #else /* USE_WINSOCK */
1434                 /* examine error */
1435                 if(error == WSAEINPROGRESS)
1436                         return 1;
1437                 else if(error == WSAEWOULDBLOCK) {
1438                         ub_winsock_tcp_wouldblock(c->ev->ev, UB_EV_WRITE);
1439                         return 1;
1440                 } else if(error != 0 && verbosity < 2)
1441                         return 0;
1442                 else if(error != 0) {
1443                         log_err_addr("tcp connect", wsa_strerror(error),
1444                                 &c->repinfo.addr, c->repinfo.addrlen);
1445 #endif /* USE_WINSOCK */
1446                         return 0;
1447                 }
1448         }
1449         if(c->ssl)
1450                 return ssl_handle_it(c);
1451
1452 #ifdef USE_MSG_FASTOPEN
1453         /* Only try this on first use of a connection that uses tfo,
1454            otherwise fall through to normal write */
1455         /* Also, TFO support on WINDOWS not implemented at the moment */
1456         if(c->tcp_do_fastopen == 1) {
1457                 /* this form of sendmsg() does both a connect() and send() so need to
1458                    look for various flavours of error*/
1459                 uint16_t len = htons(sldns_buffer_limit(buffer));
1460                 struct msghdr msg;
1461                 struct iovec iov[2];
1462                 c->tcp_do_fastopen = 0;
1463                 memset(&msg, 0, sizeof(msg));
1464                 iov[0].iov_base = (uint8_t*)&len + c->tcp_byte_count;
1465                 iov[0].iov_len = sizeof(uint16_t) - c->tcp_byte_count;
1466                 iov[1].iov_base = sldns_buffer_begin(buffer);
1467                 iov[1].iov_len = sldns_buffer_limit(buffer);
1468                 log_assert(iov[0].iov_len > 0);
1469                 log_assert(iov[1].iov_len > 0);
1470                 msg.msg_name = &c->repinfo.addr;
1471                 msg.msg_namelen = c->repinfo.addrlen;
1472                 msg.msg_iov = iov;
1473                 msg.msg_iovlen = 2;
1474                 r = sendmsg(fd, &msg, MSG_FASTOPEN);
1475                 if (r == -1) {
1476 #if defined(EINPROGRESS) && defined(EWOULDBLOCK)
1477                         /* Handshake is underway, maybe because no TFO cookie available.
1478                            Come back to write the message*/
1479                         if(errno == EINPROGRESS || errno == EWOULDBLOCK)
1480                                 return 1;
1481 #endif
1482                         if(errno == EINTR || errno == EAGAIN)
1483                                 return 1;
1484                         /* Not handling EISCONN here as shouldn't ever hit that case.*/
1485                         if(errno != EPIPE && errno != 0 && verbosity < 2)
1486                                 return 0; /* silence lots of chatter in the logs */
1487                         if(errno != EPIPE && errno != 0) {
1488                                 log_err_addr("tcp sendmsg", strerror(errno),
1489                                         &c->repinfo.addr, c->repinfo.addrlen);
1490                                 return 0;
1491                         }
1492                         /* fallthrough to nonFASTOPEN
1493                          * (MSG_FASTOPEN on Linux 3 produces EPIPE)
1494                          * we need to perform connect() */
1495                         if(connect(fd, (struct sockaddr *)&c->repinfo.addr, c->repinfo.addrlen) == -1) {
1496 #ifdef EINPROGRESS
1497                                 if(errno == EINPROGRESS)
1498                                         return 1; /* wait until connect done*/
1499 #endif
1500 #ifdef USE_WINSOCK
1501                                 if(WSAGetLastError() == WSAEINPROGRESS ||
1502                                         WSAGetLastError() == WSAEWOULDBLOCK)
1503                                         return 1; /* wait until connect done*/
1504 #endif
1505                                 if(tcp_connect_errno_needs_log(
1506                                         (struct sockaddr *)&c->repinfo.addr, c->repinfo.addrlen)) {
1507                                         log_err_addr("outgoing tcp: connect after EPIPE for fastopen",
1508                                                 strerror(errno), &c->repinfo.addr, c->repinfo.addrlen);
1509                                 }
1510                                 return 0;
1511                         }
1512
1513                 } else {
1514                         c->tcp_byte_count += r;
1515                         if(c->tcp_byte_count < sizeof(uint16_t))
1516                                 return 1;
1517                         sldns_buffer_set_position(buffer, c->tcp_byte_count -
1518                                 sizeof(uint16_t));
1519                         if(sldns_buffer_remaining(buffer) == 0) {
1520                                 tcp_callback_writer(c);
1521                                 return 1;
1522                         }
1523                 }
1524         }
1525 #endif /* USE_MSG_FASTOPEN */
1526
1527         if(c->tcp_byte_count < sizeof(uint16_t)) {
1528                 uint16_t len = htons(sldns_buffer_limit(buffer));
1529 #ifdef HAVE_WRITEV
1530                 struct iovec iov[2];
1531                 iov[0].iov_base = (uint8_t*)&len + c->tcp_byte_count;
1532                 iov[0].iov_len = sizeof(uint16_t) - c->tcp_byte_count;
1533                 iov[1].iov_base = sldns_buffer_begin(buffer);
1534                 iov[1].iov_len = sldns_buffer_limit(buffer);
1535                 log_assert(iov[0].iov_len > 0);
1536                 log_assert(iov[1].iov_len > 0);
1537                 r = writev(fd, iov, 2);
1538 #else /* HAVE_WRITEV */
1539                 r = send(fd, (void*)(((uint8_t*)&len)+c->tcp_byte_count),
1540                         sizeof(uint16_t)-c->tcp_byte_count, 0);
1541 #endif /* HAVE_WRITEV */
1542                 if(r == -1) {
1543 #ifndef USE_WINSOCK
1544 #  ifdef EPIPE
1545                         if(errno == EPIPE && verbosity < 2)
1546                                 return 0; /* silence 'broken pipe' */
1547   #endif
1548                         if(errno == EINTR || errno == EAGAIN)
1549                                 return 1;
1550 #  ifdef HAVE_WRITEV
1551                         log_err_addr("tcp writev", strerror(errno),
1552                                 &c->repinfo.addr, c->repinfo.addrlen);
1553 #  else /* HAVE_WRITEV */
1554                         log_err_addr("tcp send s", strerror(errno),
1555                                 &c->repinfo.addr, c->repinfo.addrlen);
1556 #  endif /* HAVE_WRITEV */
1557 #else
1558                         if(WSAGetLastError() == WSAENOTCONN)
1559                                 return 1;
1560                         if(WSAGetLastError() == WSAEINPROGRESS)
1561                                 return 1;
1562                         if(WSAGetLastError() == WSAEWOULDBLOCK) {
1563                                 ub_winsock_tcp_wouldblock(c->ev->ev,
1564                                         UB_EV_WRITE);
1565                                 return 1;
1566                         }
1567                         log_err_addr("tcp send s",
1568                                 wsa_strerror(WSAGetLastError()),
1569                                 &c->repinfo.addr, c->repinfo.addrlen);
1570 #endif
1571                         return 0;
1572                 }
1573                 c->tcp_byte_count += r;
1574                 if(c->tcp_byte_count < sizeof(uint16_t))
1575                         return 1;
1576                 sldns_buffer_set_position(buffer, c->tcp_byte_count -
1577                         sizeof(uint16_t));
1578                 if(sldns_buffer_remaining(buffer) == 0) {
1579                         tcp_callback_writer(c);
1580                         return 1;
1581                 }
1582         }
1583         log_assert(sldns_buffer_remaining(buffer) > 0);
1584         r = send(fd, (void*)sldns_buffer_current(buffer),
1585                 sldns_buffer_remaining(buffer), 0);
1586         if(r == -1) {
1587 #ifndef USE_WINSOCK
1588                 if(errno == EINTR || errno == EAGAIN)
1589                         return 1;
1590                 log_err_addr("tcp send r", strerror(errno),
1591                         &c->repinfo.addr, c->repinfo.addrlen);
1592 #else
1593                 if(WSAGetLastError() == WSAEINPROGRESS)
1594                         return 1;
1595                 if(WSAGetLastError() == WSAEWOULDBLOCK) {
1596                         ub_winsock_tcp_wouldblock(c->ev->ev, UB_EV_WRITE);
1597                         return 1;
1598                 }
1599                 log_err_addr("tcp send r", wsa_strerror(WSAGetLastError()),
1600                         &c->repinfo.addr, c->repinfo.addrlen);
1601 #endif
1602                 return 0;
1603         }
1604         sldns_buffer_skip(buffer, r);
1605
1606         if(sldns_buffer_remaining(buffer) == 0) {
1607                 tcp_callback_writer(c);
1608         }
1609
1610         return 1;
1611 }
1612
1613 void
1614 comm_point_tcp_handle_callback(int fd, short event, void* arg)
1615 {
1616         struct comm_point* c = (struct comm_point*)arg;
1617         log_assert(c->type == comm_tcp);
1618         ub_comm_base_now(c->ev->base);
1619
1620 #ifdef USE_DNSCRYPT
1621         /* Initialize if this is a dnscrypt socket */
1622         if(c->tcp_parent) {
1623                 c->dnscrypt = c->tcp_parent->dnscrypt;
1624         }
1625         if(c->dnscrypt && c->dnscrypt_buffer == c->buffer) {
1626                 c->dnscrypt_buffer = sldns_buffer_new(sldns_buffer_capacity(c->buffer));
1627                 if(!c->dnscrypt_buffer) {
1628                         log_err("Could not allocate dnscrypt buffer");
1629                         reclaim_tcp_handler(c);
1630                         if(!c->tcp_do_close) {
1631                                 fptr_ok(fptr_whitelist_comm_point(
1632                                         c->callback));
1633                                 (void)(*c->callback)(c, c->cb_arg,
1634                                         NETEVENT_CLOSED, NULL);
1635                         }
1636                         return;
1637                 }
1638         }
1639 #endif
1640
1641         if(event&UB_EV_READ) {
1642                 if(!comm_point_tcp_handle_read(fd, c, 0)) {
1643                         reclaim_tcp_handler(c);
1644                         if(!c->tcp_do_close) {
1645                                 fptr_ok(fptr_whitelist_comm_point(
1646                                         c->callback));
1647                                 (void)(*c->callback)(c, c->cb_arg,
1648                                         NETEVENT_CLOSED, NULL);
1649                         }
1650                 }
1651                 return;
1652         }
1653         if(event&UB_EV_WRITE) {
1654                 if(!comm_point_tcp_handle_write(fd, c)) {
1655                         reclaim_tcp_handler(c);
1656                         if(!c->tcp_do_close) {
1657                                 fptr_ok(fptr_whitelist_comm_point(
1658                                         c->callback));
1659                                 (void)(*c->callback)(c, c->cb_arg,
1660                                         NETEVENT_CLOSED, NULL);
1661                         }
1662                 }
1663                 return;
1664         }
1665         if(event&UB_EV_TIMEOUT) {
1666                 verbose(VERB_QUERY, "tcp took too long, dropped");
1667                 reclaim_tcp_handler(c);
1668                 if(!c->tcp_do_close) {
1669                         fptr_ok(fptr_whitelist_comm_point(c->callback));
1670                         (void)(*c->callback)(c, c->cb_arg,
1671                                 NETEVENT_TIMEOUT, NULL);
1672                 }
1673                 return;
1674         }
1675         log_err("Ignored event %d for tcphdl.", event);
1676 }
1677
1678 /** Make http handler free for next assignment */
1679 static void
1680 reclaim_http_handler(struct comm_point* c)
1681 {
1682         log_assert(c->type == comm_http);
1683         if(c->ssl) {
1684 #ifdef HAVE_SSL
1685                 SSL_shutdown(c->ssl);
1686                 SSL_free(c->ssl);
1687                 c->ssl = NULL;
1688 #endif
1689         }
1690         comm_point_close(c);
1691         if(c->tcp_parent) {
1692                 c->tcp_parent->cur_tcp_count--;
1693                 c->tcp_free = c->tcp_parent->tcp_free;
1694                 c->tcp_parent->tcp_free = c;
1695                 if(!c->tcp_free) {
1696                         /* re-enable listening on accept socket */
1697                         comm_point_start_listening(c->tcp_parent, -1, -1);
1698                 }
1699         }
1700 }
1701
1702 /** read more data for http (with ssl) */
1703 static int
1704 ssl_http_read_more(struct comm_point* c)
1705 {
1706 #ifdef HAVE_SSL
1707         int r;
1708         log_assert(sldns_buffer_remaining(c->buffer) > 0);
1709         ERR_clear_error();
1710         r = SSL_read(c->ssl, (void*)sldns_buffer_current(c->buffer),
1711                 (int)sldns_buffer_remaining(c->buffer));
1712         if(r <= 0) {
1713                 int want = SSL_get_error(c->ssl, r);
1714                 if(want == SSL_ERROR_ZERO_RETURN) {
1715                         return 0; /* shutdown, closed */
1716                 } else if(want == SSL_ERROR_WANT_READ) {
1717                         return 1; /* read more later */
1718                 } else if(want == SSL_ERROR_WANT_WRITE) {
1719                         c->ssl_shake_state = comm_ssl_shake_hs_write;
1720                         comm_point_listen_for_rw(c, 0, 1);
1721                         return 1;
1722                 } else if(want == SSL_ERROR_SYSCALL) {
1723                         if(errno != 0)
1724                                 log_err("SSL_read syscall: %s",
1725                                         strerror(errno));
1726                         return 0;
1727                 }
1728                 log_crypto_err("could not SSL_read");
1729                 return 0;
1730         }
1731         sldns_buffer_skip(c->buffer, (ssize_t)r);
1732         return 1;
1733 #else
1734         (void)c;
1735         return 0;
1736 #endif /* HAVE_SSL */
1737 }
1738
1739 /** read more data for http */
1740 static int
1741 http_read_more(int fd, struct comm_point* c)
1742 {
1743         ssize_t r;
1744         log_assert(sldns_buffer_remaining(c->buffer) > 0);
1745         r = recv(fd, (void*)sldns_buffer_current(c->buffer),
1746                 sldns_buffer_remaining(c->buffer), 0);
1747         if(r == 0) {
1748                 return 0;
1749         } else if(r == -1) {
1750 #ifndef USE_WINSOCK
1751                 if(errno == EINTR || errno == EAGAIN)
1752                         return 1;
1753                 log_err_addr("read (in http r)", strerror(errno),
1754                         &c->repinfo.addr, c->repinfo.addrlen);
1755 #else /* USE_WINSOCK */
1756                 if(WSAGetLastError() == WSAECONNRESET)
1757                         return 0;
1758                 if(WSAGetLastError() == WSAEINPROGRESS)
1759                         return 1;
1760                 if(WSAGetLastError() == WSAEWOULDBLOCK) {
1761                         ub_winsock_tcp_wouldblock(c->ev->ev, UB_EV_READ);
1762                         return 1;
1763                 }
1764                 log_err_addr("read (in http r)",
1765                         wsa_strerror(WSAGetLastError()),
1766                         &c->repinfo.addr, c->repinfo.addrlen);
1767 #endif
1768                 return 0;
1769         }
1770         sldns_buffer_skip(c->buffer, r);
1771         return 1;
1772 }
1773
1774 /** return true if http header has been read (one line complete) */
1775 static int
1776 http_header_done(sldns_buffer* buf)
1777 {
1778         size_t i;
1779         for(i=sldns_buffer_position(buf); i<sldns_buffer_limit(buf); i++) {
1780                 /* there was a \r before the \n, but we ignore that */
1781                 if((char)sldns_buffer_read_u8_at(buf, i) == '\n')
1782                         return 1;
1783         }
1784         return 0;
1785 }
1786
1787 /** return character string into buffer for header line, moves buffer
1788  * past that line and puts zero terminator into linefeed-newline */
1789 static char*
1790 http_header_line(sldns_buffer* buf)
1791 {
1792         char* result = (char*)sldns_buffer_current(buf);
1793         size_t i;
1794         for(i=sldns_buffer_position(buf); i<sldns_buffer_limit(buf); i++) {
1795                 /* terminate the string on the \r */
1796                 if((char)sldns_buffer_read_u8_at(buf, i) == '\r')
1797                         sldns_buffer_write_u8_at(buf, i, 0);
1798                 /* terminate on the \n and skip past the it and done */
1799                 if((char)sldns_buffer_read_u8_at(buf, i) == '\n') {
1800                         sldns_buffer_write_u8_at(buf, i, 0);
1801                         sldns_buffer_set_position(buf, i+1);
1802                         return result;
1803                 }
1804         }
1805         return NULL;
1806 }
1807
1808 /** move unread buffer to start and clear rest for putting the rest into it */
1809 static void
1810 http_moveover_buffer(sldns_buffer* buf)
1811 {
1812         size_t pos = sldns_buffer_position(buf);
1813         size_t len = sldns_buffer_remaining(buf);
1814         sldns_buffer_clear(buf);
1815         memmove(sldns_buffer_begin(buf), sldns_buffer_at(buf, pos), len);
1816         sldns_buffer_set_position(buf, len);
1817 }
1818
1819 /** a http header is complete, process it */
1820 static int
1821 http_process_initial_header(struct comm_point* c)
1822 {
1823         char* line = http_header_line(c->buffer);
1824         if(!line) return 1;
1825         verbose(VERB_ALGO, "http header: %s", line);
1826         if(strncasecmp(line, "HTTP/1.1 ", 9) == 0) {
1827                 /* check returncode */
1828                 if(line[9] != '2') {
1829                         verbose(VERB_ALGO, "http bad status %s", line+9);
1830                         return 0;
1831                 }
1832         } else if(strncasecmp(line, "Content-Length: ", 16) == 0) {
1833                 if(!c->http_is_chunked)
1834                         c->tcp_byte_count = (size_t)atoi(line+16);
1835         } else if(strncasecmp(line, "Transfer-Encoding: chunked", 19+7) == 0) {
1836                 c->tcp_byte_count = 0;
1837                 c->http_is_chunked = 1;
1838         } else if(line[0] == 0) {
1839                 /* end of initial headers */
1840                 c->http_in_headers = 0;
1841                 if(c->http_is_chunked)
1842                         c->http_in_chunk_headers = 1;
1843                 /* remove header text from front of buffer
1844                  * the buffer is going to be used to return the data segment
1845                  * itself and we don't want the header to get returned
1846                  * prepended with it */
1847                 http_moveover_buffer(c->buffer);
1848                 sldns_buffer_flip(c->buffer);
1849                 return 1;
1850         }
1851         /* ignore other headers */
1852         return 1;
1853 }
1854
1855 /** a chunk header is complete, process it, return 0=fail, 1=continue next
1856  * header line, 2=done with chunked transfer*/
1857 static int
1858 http_process_chunk_header(struct comm_point* c)
1859 {
1860         char* line = http_header_line(c->buffer);
1861         if(!line) return 1;
1862         if(c->http_in_chunk_headers == 3) {
1863                 verbose(VERB_ALGO, "http chunk trailer: %s", line);
1864                 /* are we done ? */
1865                 if(line[0] == 0 && c->tcp_byte_count == 0) {
1866                         /* callback of http reader when NETEVENT_DONE,
1867                          * end of data, with no data in buffer */
1868                         sldns_buffer_set_position(c->buffer, 0);
1869                         sldns_buffer_set_limit(c->buffer, 0);
1870                         fptr_ok(fptr_whitelist_comm_point(c->callback));
1871                         (void)(*c->callback)(c, c->cb_arg, NETEVENT_DONE, NULL);
1872                         /* return that we are done */
1873                         return 2;
1874                 }
1875                 if(line[0] == 0) {
1876                         /* continue with header of the next chunk */
1877                         c->http_in_chunk_headers = 1;
1878                         /* remove header text from front of buffer */
1879                         http_moveover_buffer(c->buffer);
1880                         sldns_buffer_flip(c->buffer);
1881                         return 1;
1882                 }
1883                 /* ignore further trail headers */
1884                 return 1;
1885         }
1886         verbose(VERB_ALGO, "http chunk header: %s", line);
1887         if(c->http_in_chunk_headers == 1) {
1888                 /* read chunked start line */
1889                 char* end = NULL;
1890                 c->tcp_byte_count = (size_t)strtol(line, &end, 16);
1891                 if(end == line)
1892                         return 0;
1893                 c->http_in_chunk_headers = 0;
1894                 /* remove header text from front of buffer */
1895                 http_moveover_buffer(c->buffer);
1896                 sldns_buffer_flip(c->buffer);
1897                 if(c->tcp_byte_count == 0) {
1898                         /* done with chunks, process chunk_trailer lines */
1899                         c->http_in_chunk_headers = 3;
1900                 }
1901                 return 1;
1902         }
1903         /* ignore other headers */
1904         return 1;
1905 }
1906
1907 /** handle nonchunked data segment */
1908 static int
1909 http_nonchunk_segment(struct comm_point* c)
1910 {
1911         /* c->buffer at position..limit has new data we read in.
1912          * the buffer itself is full of nonchunked data.
1913          * we are looking to read tcp_byte_count more data
1914          * and then the transfer is done. */
1915         size_t remainbufferlen;
1916         size_t got_now = sldns_buffer_limit(c->buffer) - c->http_stored;
1917         if(c->tcp_byte_count <= got_now) {
1918                 /* done, this is the last data fragment */
1919                 c->http_stored = 0;
1920                 sldns_buffer_set_position(c->buffer, 0);
1921                 fptr_ok(fptr_whitelist_comm_point(c->callback));
1922                 (void)(*c->callback)(c, c->cb_arg, NETEVENT_DONE, NULL);
1923                 return 1;
1924         }
1925         c->tcp_byte_count -= got_now;
1926         /* if we have the buffer space,
1927          * read more data collected into the buffer */
1928         remainbufferlen = sldns_buffer_capacity(c->buffer) -
1929                 sldns_buffer_limit(c->buffer);
1930         if(remainbufferlen >= c->tcp_byte_count ||
1931                 remainbufferlen >= 2048) {
1932                 size_t total = sldns_buffer_limit(c->buffer);
1933                 sldns_buffer_clear(c->buffer);
1934                 sldns_buffer_set_position(c->buffer, total);
1935                 c->http_stored = total;
1936                 /* return and wait to read more */
1937                 return 1;
1938         }
1939         /* call callback with this data amount, then
1940          * wait for more */
1941         c->http_stored = 0;
1942         sldns_buffer_set_position(c->buffer, 0);
1943         fptr_ok(fptr_whitelist_comm_point(c->callback));
1944         (void)(*c->callback)(c, c->cb_arg, NETEVENT_NOERROR, NULL);
1945         /* c->callback has to buffer_clear(c->buffer). */
1946         /* return and wait to read more */
1947         return 1;
1948 }
1949
1950 /** handle nonchunked data segment, return 0=fail, 1=wait, 2=process more */
1951 static int
1952 http_chunked_segment(struct comm_point* c)
1953 {
1954         /* the c->buffer has from position..limit new data we read. */
1955         /* the current chunk has length tcp_byte_count.
1956          * once we read that read more chunk headers.
1957          */
1958         size_t remainbufferlen;
1959         size_t got_now = sldns_buffer_limit(c->buffer) - c->http_stored;
1960         if(c->tcp_byte_count <= got_now) {
1961                 /* the chunk has completed (with perhaps some extra data
1962                  * from next chunk header and next chunk) */
1963                 /* save too much info into temp buffer */
1964                 size_t fraglen;
1965                 struct comm_reply repinfo;
1966                 c->http_stored = 0;
1967                 sldns_buffer_skip(c->buffer, (ssize_t)c->tcp_byte_count);
1968                 sldns_buffer_clear(c->http_temp);
1969                 sldns_buffer_write(c->http_temp,
1970                         sldns_buffer_current(c->buffer),
1971                         sldns_buffer_remaining(c->buffer));
1972                 sldns_buffer_flip(c->http_temp);
1973
1974                 /* callback with this fragment */
1975                 fraglen = sldns_buffer_position(c->buffer);
1976                 sldns_buffer_set_position(c->buffer, 0);
1977                 sldns_buffer_set_limit(c->buffer, fraglen);
1978                 repinfo = c->repinfo;
1979                 fptr_ok(fptr_whitelist_comm_point(c->callback));
1980                 (void)(*c->callback)(c, c->cb_arg, NETEVENT_NOERROR, &repinfo);
1981                 /* c->callback has to buffer_clear(). */
1982
1983                 /* is commpoint deleted? */
1984                 if(!repinfo.c) {
1985                         return 1;
1986                 }
1987                 /* copy waiting info */
1988                 sldns_buffer_clear(c->buffer);
1989                 sldns_buffer_write(c->buffer,
1990                         sldns_buffer_begin(c->http_temp),
1991                         sldns_buffer_remaining(c->http_temp));
1992                 sldns_buffer_flip(c->buffer);
1993                 /* process end of chunk trailer header lines, until
1994                  * an empty line */
1995                 c->http_in_chunk_headers = 3;
1996                 /* process more data in buffer (if any) */
1997                 return 2;
1998         }
1999         c->tcp_byte_count -= got_now;
2000
2001         /* if we have the buffer space,
2002          * read more data collected into the buffer */
2003         remainbufferlen = sldns_buffer_capacity(c->buffer) -
2004                 sldns_buffer_limit(c->buffer);
2005         if(remainbufferlen >= c->tcp_byte_count ||
2006                 remainbufferlen >= 2048) {
2007                 size_t total = sldns_buffer_limit(c->buffer);
2008                 sldns_buffer_clear(c->buffer);
2009                 sldns_buffer_set_position(c->buffer, total);
2010                 c->http_stored = total;
2011                 /* return and wait to read more */
2012                 return 1;
2013         }
2014
2015         /* callback of http reader for a new part of the data */
2016         c->http_stored = 0;
2017         sldns_buffer_set_position(c->buffer, 0);
2018         fptr_ok(fptr_whitelist_comm_point(c->callback));
2019         (void)(*c->callback)(c, c->cb_arg, NETEVENT_NOERROR, NULL);
2020         /* c->callback has to buffer_clear(c->buffer). */
2021         /* return and wait to read more */
2022         return 1;
2023 }
2024
2025 /**
2026  * Handle http reading callback.
2027  * @param fd: file descriptor of socket.
2028  * @param c: comm point to read from into buffer.
2029  * @return: 0 on error
2030  */
2031 static int
2032 comm_point_http_handle_read(int fd, struct comm_point* c)
2033 {
2034         log_assert(c->type == comm_http);
2035         log_assert(fd != -1);
2036
2037         /* if we are in ssl handshake, handle SSL handshake */
2038 #ifdef HAVE_SSL
2039         if(c->ssl && c->ssl_shake_state != comm_ssl_shake_none) {
2040                 if(!ssl_handshake(c))
2041                         return 0;
2042                 if(c->ssl_shake_state != comm_ssl_shake_none)
2043                         return 1;
2044         }
2045 #endif /* HAVE_SSL */
2046
2047         if(!c->tcp_is_reading)
2048                 return 1;
2049         /* read more data */
2050         if(c->ssl) {
2051                 if(!ssl_http_read_more(c))
2052                         return 0;
2053         } else {
2054                 if(!http_read_more(fd, c))
2055                         return 0;
2056         }
2057
2058         sldns_buffer_flip(c->buffer);
2059         while(sldns_buffer_remaining(c->buffer) > 0) {
2060                 /* if we are reading headers, read more headers */
2061                 if(c->http_in_headers || c->http_in_chunk_headers) {
2062                         /* if header is done, process the header */
2063                         if(!http_header_done(c->buffer)) {
2064                                 /* copy remaining data to front of buffer
2065                                  * and set rest for writing into it */
2066                                 http_moveover_buffer(c->buffer);
2067                                 /* return and wait to read more */
2068                                 return 1;
2069                         }
2070                         if(!c->http_in_chunk_headers) {
2071                                 /* process initial headers */
2072                                 if(!http_process_initial_header(c))
2073                                         return 0;
2074                         } else {
2075                                 /* process chunk headers */
2076                                 int r = http_process_chunk_header(c);
2077                                 if(r == 0) return 0;
2078                                 if(r == 2) return 1; /* done */
2079                                 /* r == 1, continue */
2080                         }
2081                         /* see if we have more to process */
2082                         continue;
2083                 }
2084
2085                 if(!c->http_is_chunked) {
2086                         /* if we are reading nonchunks, process that*/
2087                         return http_nonchunk_segment(c);
2088                 } else {
2089                         /* if we are reading chunks, read the chunk */
2090                         int r = http_chunked_segment(c);
2091                         if(r == 0) return 0;
2092                         if(r == 1) return 1;
2093                         continue;
2094                 }
2095         }
2096         /* broke out of the loop; could not process header instead need
2097          * to read more */
2098         /* moveover any remaining data and read more data */
2099         http_moveover_buffer(c->buffer);
2100         /* return and wait to read more */
2101         return 1;
2102 }
2103
2104 /** check pending connect for http */
2105 static int
2106 http_check_connect(int fd, struct comm_point* c)
2107 {
2108         /* check for pending error from nonblocking connect */
2109         /* from Stevens, unix network programming, vol1, 3rd ed, p450*/
2110         int error = 0;
2111         socklen_t len = (socklen_t)sizeof(error);
2112         if(getsockopt(fd, SOL_SOCKET, SO_ERROR, (void*)&error,
2113                 &len) < 0){
2114 #ifndef USE_WINSOCK
2115                 error = errno; /* on solaris errno is error */
2116 #else /* USE_WINSOCK */
2117                 error = WSAGetLastError();
2118 #endif
2119         }
2120 #ifndef USE_WINSOCK
2121 #if defined(EINPROGRESS) && defined(EWOULDBLOCK)
2122         if(error == EINPROGRESS || error == EWOULDBLOCK)
2123                 return 1; /* try again later */
2124         else
2125 #endif
2126         if(error != 0 && verbosity < 2)
2127                 return 0; /* silence lots of chatter in the logs */
2128         else if(error != 0) {
2129                 log_err_addr("http connect", strerror(error),
2130                         &c->repinfo.addr, c->repinfo.addrlen);
2131 #else /* USE_WINSOCK */
2132         /* examine error */
2133         if(error == WSAEINPROGRESS)
2134                 return 1;
2135         else if(error == WSAEWOULDBLOCK) {
2136                 ub_winsock_tcp_wouldblock(c->ev->ev, UB_EV_WRITE);
2137                 return 1;
2138         } else if(error != 0 && verbosity < 2)
2139                 return 0;
2140         else if(error != 0) {
2141                 log_err_addr("http connect", wsa_strerror(error),
2142                         &c->repinfo.addr, c->repinfo.addrlen);
2143 #endif /* USE_WINSOCK */
2144                 return 0;
2145         }
2146         /* keep on processing this socket */
2147         return 2;
2148 }
2149
2150 /** write more data for http (with ssl) */
2151 static int
2152 ssl_http_write_more(struct comm_point* c)
2153 {
2154 #ifdef HAVE_SSL
2155         int r;
2156         log_assert(sldns_buffer_remaining(c->buffer) > 0);
2157         ERR_clear_error();
2158         r = SSL_write(c->ssl, (void*)sldns_buffer_current(c->buffer),
2159                 (int)sldns_buffer_remaining(c->buffer));
2160         if(r <= 0) {
2161                 int want = SSL_get_error(c->ssl, r);
2162                 if(want == SSL_ERROR_ZERO_RETURN) {
2163                         return 0; /* closed */
2164                 } else if(want == SSL_ERROR_WANT_READ) {
2165                         c->ssl_shake_state = comm_ssl_shake_read;
2166                         comm_point_listen_for_rw(c, 1, 0);
2167                         return 1; /* wait for read condition */
2168                 } else if(want == SSL_ERROR_WANT_WRITE) {
2169                         return 1; /* write more later */
2170                 } else if(want == SSL_ERROR_SYSCALL) {
2171                         if(errno != 0)
2172                                 log_err("SSL_write syscall: %s",
2173                                         strerror(errno));
2174                         return 0;
2175                 }
2176                 log_crypto_err("could not SSL_write");
2177                 return 0;
2178         }
2179         sldns_buffer_skip(c->buffer, (ssize_t)r);
2180         return 1;
2181 #else
2182         (void)c;
2183         return 0;
2184 #endif /* HAVE_SSL */
2185 }
2186
2187 /** write more data for http */
2188 static int
2189 http_write_more(int fd, struct comm_point* c)
2190 {
2191         ssize_t r;
2192         log_assert(sldns_buffer_remaining(c->buffer) > 0);
2193         r = send(fd, (void*)sldns_buffer_current(c->buffer),
2194                 sldns_buffer_remaining(c->buffer), 0);
2195         if(r == -1) {
2196 #ifndef USE_WINSOCK
2197                 if(errno == EINTR || errno == EAGAIN)
2198                         return 1;
2199                 log_err_addr("http send r", strerror(errno),
2200                         &c->repinfo.addr, c->repinfo.addrlen);
2201 #else
2202                 if(WSAGetLastError() == WSAEINPROGRESS)
2203                         return 1;
2204                 if(WSAGetLastError() == WSAEWOULDBLOCK) {
2205                         ub_winsock_tcp_wouldblock(c->ev->ev, UB_EV_WRITE);
2206                         return 1;
2207                 }
2208                 log_err_addr("http send r", wsa_strerror(WSAGetLastError()),
2209                         &c->repinfo.addr, c->repinfo.addrlen);
2210 #endif
2211                 return 0;
2212         }
2213         sldns_buffer_skip(c->buffer, r);
2214         return 1;
2215 }
2216
2217 /**
2218  * Handle http writing callback.
2219  * @param fd: file descriptor of socket.
2220  * @param c: comm point to write buffer out of.
2221  * @return: 0 on error
2222  */
2223 static int
2224 comm_point_http_handle_write(int fd, struct comm_point* c)
2225 {
2226         log_assert(c->type == comm_http);
2227         log_assert(fd != -1);
2228
2229         /* check pending connect errors, if that fails, we wait for more,
2230          * or we can continue to write contents */
2231         if(c->tcp_check_nb_connect) {
2232                 int r = http_check_connect(fd, c);
2233                 if(r == 0) return 0;
2234                 if(r == 1) return 1;
2235                 c->tcp_check_nb_connect = 0;
2236         }
2237         /* if we are in ssl handshake, handle SSL handshake */
2238 #ifdef HAVE_SSL
2239         if(c->ssl && c->ssl_shake_state != comm_ssl_shake_none) {
2240                 if(!ssl_handshake(c))
2241                         return 0;
2242                 if(c->ssl_shake_state != comm_ssl_shake_none)
2243                         return 1;
2244         }
2245 #endif /* HAVE_SSL */
2246         if(c->tcp_is_reading)
2247                 return 1;
2248         /* if we are writing, write more */
2249         if(c->ssl) {
2250                 if(!ssl_http_write_more(c))
2251                         return 0;
2252         } else {
2253                 if(!http_write_more(fd, c))
2254                         return 0;
2255         }
2256
2257         /* we write a single buffer contents, that can contain
2258          * the http request, and then flip to read the results */
2259         /* see if write is done */
2260         if(sldns_buffer_remaining(c->buffer) == 0) {
2261                 sldns_buffer_clear(c->buffer);
2262                 if(c->tcp_do_toggle_rw)
2263                         c->tcp_is_reading = 1;
2264                 c->tcp_byte_count = 0;
2265                 /* switch from listening(write) to listening(read) */
2266                 comm_point_stop_listening(c);
2267                 comm_point_start_listening(c, -1, -1);
2268         }
2269         return 1;
2270 }
2271
2272 void
2273 comm_point_http_handle_callback(int fd, short event, void* arg)
2274 {
2275         struct comm_point* c = (struct comm_point*)arg;
2276         log_assert(c->type == comm_http);
2277         ub_comm_base_now(c->ev->base);
2278
2279         if(event&UB_EV_READ) {
2280                 if(!comm_point_http_handle_read(fd, c)) {
2281                         reclaim_http_handler(c);
2282                         if(!c->tcp_do_close) {
2283                                 fptr_ok(fptr_whitelist_comm_point(
2284                                         c->callback));
2285                                 (void)(*c->callback)(c, c->cb_arg,
2286                                         NETEVENT_CLOSED, NULL);
2287                         }
2288                 }
2289                 return;
2290         }
2291         if(event&UB_EV_WRITE) {
2292                 if(!comm_point_http_handle_write(fd, c)) {
2293                         reclaim_http_handler(c);
2294                         if(!c->tcp_do_close) {
2295                                 fptr_ok(fptr_whitelist_comm_point(
2296                                         c->callback));
2297                                 (void)(*c->callback)(c, c->cb_arg,
2298                                         NETEVENT_CLOSED, NULL);
2299                         }
2300                 }
2301                 return;
2302         }
2303         if(event&UB_EV_TIMEOUT) {
2304                 verbose(VERB_QUERY, "http took too long, dropped");
2305                 reclaim_http_handler(c);
2306                 if(!c->tcp_do_close) {
2307                         fptr_ok(fptr_whitelist_comm_point(c->callback));
2308                         (void)(*c->callback)(c, c->cb_arg,
2309                                 NETEVENT_TIMEOUT, NULL);
2310                 }
2311                 return;
2312         }
2313         log_err("Ignored event %d for httphdl.", event);
2314 }
2315
2316 void comm_point_local_handle_callback(int fd, short event, void* arg)
2317 {
2318         struct comm_point* c = (struct comm_point*)arg;
2319         log_assert(c->type == comm_local);
2320         ub_comm_base_now(c->ev->base);
2321
2322         if(event&UB_EV_READ) {
2323                 if(!comm_point_tcp_handle_read(fd, c, 1)) {
2324                         fptr_ok(fptr_whitelist_comm_point(c->callback));
2325                         (void)(*c->callback)(c, c->cb_arg, NETEVENT_CLOSED,
2326                                 NULL);
2327                 }
2328                 return;
2329         }
2330         log_err("Ignored event %d for localhdl.", event);
2331 }
2332
2333 void comm_point_raw_handle_callback(int ATTR_UNUSED(fd),
2334         short event, void* arg)
2335 {
2336         struct comm_point* c = (struct comm_point*)arg;
2337         int err = NETEVENT_NOERROR;
2338         log_assert(c->type == comm_raw);
2339         ub_comm_base_now(c->ev->base);
2340
2341         if(event&UB_EV_TIMEOUT)
2342                 err = NETEVENT_TIMEOUT;
2343         fptr_ok(fptr_whitelist_comm_point_raw(c->callback));
2344         (void)(*c->callback)(c, c->cb_arg, err, NULL);
2345 }
2346
2347 struct comm_point*
2348 comm_point_create_udp(struct comm_base *base, int fd, sldns_buffer* buffer,
2349         comm_point_callback_type* callback, void* callback_arg)
2350 {
2351         struct comm_point* c = (struct comm_point*)calloc(1,
2352                 sizeof(struct comm_point));
2353         short evbits;
2354         if(!c)
2355                 return NULL;
2356         c->ev = (struct internal_event*)calloc(1,
2357                 sizeof(struct internal_event));
2358         if(!c->ev) {
2359                 free(c);
2360                 return NULL;
2361         }
2362         c->ev->base = base;
2363         c->fd = fd;
2364         c->buffer = buffer;
2365         c->timeout = NULL;
2366         c->tcp_is_reading = 0;
2367         c->tcp_byte_count = 0;
2368         c->tcp_parent = NULL;
2369         c->max_tcp_count = 0;
2370         c->cur_tcp_count = 0;
2371         c->tcp_handlers = NULL;
2372         c->tcp_free = NULL;
2373         c->type = comm_udp;
2374         c->tcp_do_close = 0;
2375         c->do_not_close = 0;
2376         c->tcp_do_toggle_rw = 0;
2377         c->tcp_check_nb_connect = 0;
2378 #ifdef USE_MSG_FASTOPEN
2379         c->tcp_do_fastopen = 0;
2380 #endif
2381 #ifdef USE_DNSCRYPT
2382         c->dnscrypt = 0;
2383         c->dnscrypt_buffer = buffer;
2384 #endif
2385         c->inuse = 0;
2386         c->callback = callback;
2387         c->cb_arg = callback_arg;
2388         evbits = UB_EV_READ | UB_EV_PERSIST;
2389         /* ub_event stuff */
2390         c->ev->ev = ub_event_new(base->eb->base, c->fd, evbits,
2391                 comm_point_udp_callback, c);
2392         if(c->ev->ev == NULL) {
2393                 log_err("could not baseset udp event");
2394                 comm_point_delete(c);
2395                 return NULL;
2396         }
2397         if(fd!=-1 && ub_event_add(c->ev->ev, c->timeout) != 0 ) {
2398                 log_err("could not add udp event");
2399                 comm_point_delete(c);
2400                 return NULL;
2401         }
2402         return c;
2403 }
2404
2405 struct comm_point*
2406 comm_point_create_udp_ancil(struct comm_base *base, int fd,
2407         sldns_buffer* buffer,
2408         comm_point_callback_type* callback, void* callback_arg)
2409 {
2410         struct comm_point* c = (struct comm_point*)calloc(1,
2411                 sizeof(struct comm_point));
2412         short evbits;
2413         if(!c)
2414                 return NULL;
2415         c->ev = (struct internal_event*)calloc(1,
2416                 sizeof(struct internal_event));
2417         if(!c->ev) {
2418                 free(c);
2419                 return NULL;
2420         }
2421         c->ev->base = base;
2422         c->fd = fd;
2423         c->buffer = buffer;
2424         c->timeout = NULL;
2425         c->tcp_is_reading = 0;
2426         c->tcp_byte_count = 0;
2427         c->tcp_parent = NULL;
2428         c->max_tcp_count = 0;
2429         c->cur_tcp_count = 0;
2430         c->tcp_handlers = NULL;
2431         c->tcp_free = NULL;
2432         c->type = comm_udp;
2433         c->tcp_do_close = 0;
2434         c->do_not_close = 0;
2435 #ifdef USE_DNSCRYPT
2436         c->dnscrypt = 0;
2437         c->dnscrypt_buffer = buffer;
2438 #endif
2439         c->inuse = 0;
2440         c->tcp_do_toggle_rw = 0;
2441         c->tcp_check_nb_connect = 0;
2442 #ifdef USE_MSG_FASTOPEN
2443         c->tcp_do_fastopen = 0;
2444 #endif
2445         c->callback = callback;
2446         c->cb_arg = callback_arg;
2447         evbits = UB_EV_READ | UB_EV_PERSIST;
2448         /* ub_event stuff */
2449         c->ev->ev = ub_event_new(base->eb->base, c->fd, evbits,
2450                 comm_point_udp_ancil_callback, c);
2451         if(c->ev->ev == NULL) {
2452                 log_err("could not baseset udp event");
2453                 comm_point_delete(c);
2454                 return NULL;
2455         }
2456         if(fd!=-1 && ub_event_add(c->ev->ev, c->timeout) != 0 ) {
2457                 log_err("could not add udp event");
2458                 comm_point_delete(c);
2459                 return NULL;
2460         }
2461         return c;
2462 }
2463
2464 static struct comm_point*
2465 comm_point_create_tcp_handler(struct comm_base *base,
2466         struct comm_point* parent, size_t bufsize,
2467         comm_point_callback_type* callback, void* callback_arg)
2468 {
2469         struct comm_point* c = (struct comm_point*)calloc(1,
2470                 sizeof(struct comm_point));
2471         short evbits;
2472         if(!c)
2473                 return NULL;
2474         c->ev = (struct internal_event*)calloc(1,
2475                 sizeof(struct internal_event));
2476         if(!c->ev) {
2477                 free(c);
2478                 return NULL;
2479         }
2480         c->ev->base = base;
2481         c->fd = -1;
2482         c->buffer = sldns_buffer_new(bufsize);
2483         if(!c->buffer) {
2484                 free(c->ev);
2485                 free(c);
2486                 return NULL;
2487         }
2488         c->timeout = (struct timeval*)malloc(sizeof(struct timeval));
2489         if(!c->timeout) {
2490                 sldns_buffer_free(c->buffer);
2491                 free(c->ev);
2492                 free(c);
2493                 return NULL;
2494         }
2495         c->tcp_is_reading = 0;
2496         c->tcp_byte_count = 0;
2497         c->tcp_parent = parent;
2498         c->max_tcp_count = 0;
2499         c->cur_tcp_count = 0;
2500         c->tcp_handlers = NULL;
2501         c->tcp_free = NULL;
2502         c->type = comm_tcp;
2503         c->tcp_do_close = 0;
2504         c->do_not_close = 0;
2505         c->tcp_do_toggle_rw = 1;
2506         c->tcp_check_nb_connect = 0;
2507 #ifdef USE_MSG_FASTOPEN
2508         c->tcp_do_fastopen = 0;
2509 #endif
2510 #ifdef USE_DNSCRYPT
2511         c->dnscrypt = 0;
2512         /* We don't know just yet if this is a dnscrypt channel. Allocation
2513          * will be done when handling the callback. */
2514         c->dnscrypt_buffer = c->buffer;
2515 #endif
2516         c->repinfo.c = c;
2517         c->callback = callback;
2518         c->cb_arg = callback_arg;
2519         /* add to parent free list */
2520         c->tcp_free = parent->tcp_free;
2521         parent->tcp_free = c;
2522         /* ub_event stuff */
2523         evbits = UB_EV_PERSIST | UB_EV_READ | UB_EV_TIMEOUT;
2524         c->ev->ev = ub_event_new(base->eb->base, c->fd, evbits,
2525                 comm_point_tcp_handle_callback, c);
2526         if(c->ev->ev == NULL)
2527         {
2528                 log_err("could not basetset tcphdl event");
2529                 parent->tcp_free = c->tcp_free;
2530                 free(c->ev);
2531                 free(c);
2532                 return NULL;
2533         }
2534         return c;
2535 }
2536
2537 struct comm_point*
2538 comm_point_create_tcp(struct comm_base *base, int fd, int num, size_t bufsize,
2539         comm_point_callback_type* callback, void* callback_arg)
2540 {
2541         struct comm_point* c = (struct comm_point*)calloc(1,
2542                 sizeof(struct comm_point));
2543         short evbits;
2544         int i;
2545         /* first allocate the TCP accept listener */
2546         if(!c)
2547                 return NULL;
2548         c->ev = (struct internal_event*)calloc(1,
2549                 sizeof(struct internal_event));
2550         if(!c->ev) {
2551                 free(c);
2552                 return NULL;
2553         }
2554         c->ev->base = base;
2555         c->fd = fd;
2556         c->buffer = NULL;
2557         c->timeout = NULL;
2558         c->tcp_is_reading = 0;
2559         c->tcp_byte_count = 0;
2560         c->tcp_parent = NULL;
2561         c->max_tcp_count = num;
2562         c->cur_tcp_count = 0;
2563         c->tcp_handlers = (struct comm_point**)calloc((size_t)num,
2564                 sizeof(struct comm_point*));
2565         if(!c->tcp_handlers) {
2566                 free(c->ev);
2567                 free(c);
2568                 return NULL;
2569         }
2570         c->tcp_free = NULL;
2571         c->type = comm_tcp_accept;
2572         c->tcp_do_close = 0;
2573         c->do_not_close = 0;
2574         c->tcp_do_toggle_rw = 0;
2575         c->tcp_check_nb_connect = 0;
2576 #ifdef USE_MSG_FASTOPEN
2577         c->tcp_do_fastopen = 0;
2578 #endif
2579 #ifdef USE_DNSCRYPT
2580         c->dnscrypt = 0;
2581         c->dnscrypt_buffer = NULL;
2582 #endif
2583         c->callback = NULL;
2584         c->cb_arg = NULL;
2585         evbits = UB_EV_READ | UB_EV_PERSIST;
2586         /* ub_event stuff */
2587         c->ev->ev = ub_event_new(base->eb->base, c->fd, evbits,
2588                 comm_point_tcp_accept_callback, c);
2589         if(c->ev->ev == NULL) {
2590                 log_err("could not baseset tcpacc event");
2591                 comm_point_delete(c);
2592                 return NULL;
2593         }
2594         if (ub_event_add(c->ev->ev, c->timeout) != 0) {
2595                 log_err("could not add tcpacc event");
2596                 comm_point_delete(c);
2597                 return NULL;
2598         }
2599         /* now prealloc the tcp handlers */
2600         for(i=0; i<num; i++) {
2601                 c->tcp_handlers[i] = comm_point_create_tcp_handler(base,
2602                         c, bufsize, callback, callback_arg);
2603                 if(!c->tcp_handlers[i]) {
2604                         comm_point_delete(c);
2605                         return NULL;
2606                 }
2607         }
2608
2609         return c;
2610 }
2611
2612 struct comm_point*
2613 comm_point_create_tcp_out(struct comm_base *base, size_t bufsize,
2614         comm_point_callback_type* callback, void* callback_arg)
2615 {
2616         struct comm_point* c = (struct comm_point*)calloc(1,
2617                 sizeof(struct comm_point));
2618         short evbits;
2619         if(!c)
2620                 return NULL;
2621         c->ev = (struct internal_event*)calloc(1,
2622                 sizeof(struct internal_event));
2623         if(!c->ev) {
2624                 free(c);
2625                 return NULL;
2626         }
2627         c->ev->base = base;
2628         c->fd = -1;
2629         c->buffer = sldns_buffer_new(bufsize);
2630         if(!c->buffer) {
2631                 free(c->ev);
2632                 free(c);
2633                 return NULL;
2634         }
2635         c->timeout = NULL;
2636         c->tcp_is_reading = 0;
2637         c->tcp_byte_count = 0;
2638         c->tcp_parent = NULL;
2639         c->max_tcp_count = 0;
2640         c->cur_tcp_count = 0;
2641         c->tcp_handlers = NULL;
2642         c->tcp_free = NULL;
2643         c->type = comm_tcp;
2644         c->tcp_do_close = 0;
2645         c->do_not_close = 0;
2646         c->tcp_do_toggle_rw = 1;
2647         c->tcp_check_nb_connect = 1;
2648 #ifdef USE_MSG_FASTOPEN
2649         c->tcp_do_fastopen = 1;
2650 #endif
2651 #ifdef USE_DNSCRYPT
2652         c->dnscrypt = 0;
2653         c->dnscrypt_buffer = c->buffer;
2654 #endif
2655         c->repinfo.c = c;
2656         c->callback = callback;
2657         c->cb_arg = callback_arg;
2658         evbits = UB_EV_PERSIST | UB_EV_WRITE;
2659         c->ev->ev = ub_event_new(base->eb->base, c->fd, evbits,
2660                 comm_point_tcp_handle_callback, c);
2661         if(c->ev->ev == NULL)
2662         {
2663                 log_err("could not baseset tcpout event");
2664                 sldns_buffer_free(c->buffer);
2665                 free(c->ev);
2666                 free(c);
2667                 return NULL;
2668         }
2669
2670         return c;
2671 }
2672
2673 struct comm_point*
2674 comm_point_create_http_out(struct comm_base *base, size_t bufsize,
2675         comm_point_callback_type* callback, void* callback_arg,
2676         sldns_buffer* temp)
2677 {
2678         struct comm_point* c = (struct comm_point*)calloc(1,
2679                 sizeof(struct comm_point));
2680         short evbits;
2681         if(!c)
2682                 return NULL;
2683         c->ev = (struct internal_event*)calloc(1,
2684                 sizeof(struct internal_event));
2685         if(!c->ev) {
2686                 free(c);
2687                 return NULL;
2688         }
2689         c->ev->base = base;
2690         c->fd = -1;
2691         c->buffer = sldns_buffer_new(bufsize);
2692         if(!c->buffer) {
2693                 free(c->ev);
2694                 free(c);
2695                 return NULL;
2696         }
2697         c->timeout = NULL;
2698         c->tcp_is_reading = 0;
2699         c->tcp_byte_count = 0;
2700         c->tcp_parent = NULL;
2701         c->max_tcp_count = 0;
2702         c->cur_tcp_count = 0;
2703         c->tcp_handlers = NULL;
2704         c->tcp_free = NULL;
2705         c->type = comm_http;
2706         c->tcp_do_close = 0;
2707         c->do_not_close = 0;
2708         c->tcp_do_toggle_rw = 1;
2709         c->tcp_check_nb_connect = 1;
2710         c->http_in_headers = 1;
2711         c->http_in_chunk_headers = 0;
2712         c->http_is_chunked = 0;
2713         c->http_temp = temp;
2714 #ifdef USE_MSG_FASTOPEN
2715         c->tcp_do_fastopen = 1;
2716 #endif
2717 #ifdef USE_DNSCRYPT
2718         c->dnscrypt = 0;
2719         c->dnscrypt_buffer = c->buffer;
2720 #endif
2721         c->repinfo.c = c;
2722         c->callback = callback;
2723         c->cb_arg = callback_arg;
2724         evbits = UB_EV_PERSIST | UB_EV_WRITE;
2725         c->ev->ev = ub_event_new(base->eb->base, c->fd, evbits,
2726                 comm_point_http_handle_callback, c);
2727         if(c->ev->ev == NULL)
2728         {
2729                 log_err("could not baseset tcpout event");
2730 #ifdef HAVE_SSL
2731                 SSL_free(c->ssl);
2732 #endif
2733                 sldns_buffer_free(c->buffer);
2734                 free(c->ev);
2735                 free(c);
2736                 return NULL;
2737         }
2738
2739         return c;
2740 }
2741
2742 struct comm_point*
2743 comm_point_create_local(struct comm_base *base, int fd, size_t bufsize,
2744         comm_point_callback_type* callback, void* callback_arg)
2745 {
2746         struct comm_point* c = (struct comm_point*)calloc(1,
2747                 sizeof(struct comm_point));
2748         short evbits;
2749         if(!c)
2750                 return NULL;
2751         c->ev = (struct internal_event*)calloc(1,
2752                 sizeof(struct internal_event));
2753         if(!c->ev) {
2754                 free(c);
2755                 return NULL;
2756         }
2757         c->ev->base = base;
2758         c->fd = fd;
2759         c->buffer = sldns_buffer_new(bufsize);
2760         if(!c->buffer) {
2761                 free(c->ev);
2762                 free(c);
2763                 return NULL;
2764         }
2765         c->timeout = NULL;
2766         c->tcp_is_reading = 1;
2767         c->tcp_byte_count = 0;
2768         c->tcp_parent = NULL;
2769         c->max_tcp_count = 0;
2770         c->cur_tcp_count = 0;
2771         c->tcp_handlers = NULL;
2772         c->tcp_free = NULL;
2773         c->type = comm_local;
2774         c->tcp_do_close = 0;
2775         c->do_not_close = 1;
2776         c->tcp_do_toggle_rw = 0;
2777         c->tcp_check_nb_connect = 0;
2778 #ifdef USE_MSG_FASTOPEN
2779         c->tcp_do_fastopen = 0;
2780 #endif
2781 #ifdef USE_DNSCRYPT
2782         c->dnscrypt = 0;
2783         c->dnscrypt_buffer = c->buffer;
2784 #endif
2785         c->callback = callback;
2786         c->cb_arg = callback_arg;
2787         /* ub_event stuff */
2788         evbits = UB_EV_PERSIST | UB_EV_READ;
2789         c->ev->ev = ub_event_new(base->eb->base, c->fd, evbits,
2790                 comm_point_local_handle_callback, c);
2791         if(c->ev->ev == NULL) {
2792                 log_err("could not baseset localhdl event");
2793                 free(c->ev);
2794                 free(c);
2795                 return NULL;
2796         }
2797         if (ub_event_add(c->ev->ev, c->timeout) != 0) {
2798                 log_err("could not add localhdl event");
2799                 ub_event_free(c->ev->ev);
2800                 free(c->ev);
2801                 free(c);
2802                 return NULL;
2803         }
2804         return c;
2805 }
2806
2807 struct comm_point*
2808 comm_point_create_raw(struct comm_base* base, int fd, int writing,
2809         comm_point_callback_type* callback, void* callback_arg)
2810 {
2811         struct comm_point* c = (struct comm_point*)calloc(1,
2812                 sizeof(struct comm_point));
2813         short evbits;
2814         if(!c)
2815                 return NULL;
2816         c->ev = (struct internal_event*)calloc(1,
2817                 sizeof(struct internal_event));
2818         if(!c->ev) {
2819                 free(c);
2820                 return NULL;
2821         }
2822         c->ev->base = base;
2823         c->fd = fd;
2824         c->buffer = NULL;
2825         c->timeout = NULL;
2826         c->tcp_is_reading = 0;
2827         c->tcp_byte_count = 0;
2828         c->tcp_parent = NULL;
2829         c->max_tcp_count = 0;
2830         c->cur_tcp_count = 0;
2831         c->tcp_handlers = NULL;
2832         c->tcp_free = NULL;
2833         c->type = comm_raw;
2834         c->tcp_do_close = 0;
2835         c->do_not_close = 1;
2836         c->tcp_do_toggle_rw = 0;
2837         c->tcp_check_nb_connect = 0;
2838 #ifdef USE_MSG_FASTOPEN
2839         c->tcp_do_fastopen = 0;
2840 #endif
2841 #ifdef USE_DNSCRYPT
2842         c->dnscrypt = 0;
2843         c->dnscrypt_buffer = c->buffer;
2844 #endif
2845         c->callback = callback;
2846         c->cb_arg = callback_arg;
2847         /* ub_event stuff */
2848         if(writing)
2849                 evbits = UB_EV_PERSIST | UB_EV_WRITE;
2850         else    evbits = UB_EV_PERSIST | UB_EV_READ;
2851         c->ev->ev = ub_event_new(base->eb->base, c->fd, evbits,
2852                 comm_point_raw_handle_callback, c);
2853         if(c->ev->ev == NULL) {
2854                 log_err("could not baseset rawhdl event");
2855                 free(c->ev);
2856                 free(c);
2857                 return NULL;
2858         }
2859         if (ub_event_add(c->ev->ev, c->timeout) != 0) {
2860                 log_err("could not add rawhdl event");
2861                 ub_event_free(c->ev->ev);
2862                 free(c->ev);
2863                 free(c);
2864                 return NULL;
2865         }
2866         return c;
2867 }
2868
2869 void
2870 comm_point_close(struct comm_point* c)
2871 {
2872         if(!c)
2873                 return;
2874         if(c->fd != -1)
2875                 if(ub_event_del(c->ev->ev) != 0) {
2876                         log_err("could not event_del on close");
2877                 }
2878         /* close fd after removing from event lists, or epoll.. is messed up */
2879         if(c->fd != -1 && !c->do_not_close) {
2880                 verbose(VERB_ALGO, "close fd %d", c->fd);
2881 #ifndef USE_WINSOCK
2882                 close(c->fd);
2883 #else
2884                 closesocket(c->fd);
2885 #endif
2886         }
2887         c->fd = -1;
2888 }
2889
2890 void
2891 comm_point_delete(struct comm_point* c)
2892 {
2893         if(!c)
2894                 return;
2895         if((c->type == comm_tcp || c->type == comm_http) && c->ssl) {
2896 #ifdef HAVE_SSL
2897                 SSL_shutdown(c->ssl);
2898                 SSL_free(c->ssl);
2899 #endif
2900         }
2901         comm_point_close(c);
2902         if(c->tcp_handlers) {
2903                 int i;
2904                 for(i=0; i<c->max_tcp_count; i++)
2905                         comm_point_delete(c->tcp_handlers[i]);
2906                 free(c->tcp_handlers);
2907         }
2908         free(c->timeout);
2909         if(c->type == comm_tcp || c->type == comm_local || c->type == comm_http) {
2910                 sldns_buffer_free(c->buffer);
2911 #ifdef USE_DNSCRYPT
2912                 if(c->dnscrypt && c->dnscrypt_buffer != c->buffer) {
2913                         sldns_buffer_free(c->dnscrypt_buffer);
2914                 }
2915 #endif
2916         }
2917         ub_event_free(c->ev->ev);
2918         free(c->ev);
2919         free(c);
2920 }
2921
2922 void
2923 comm_point_send_reply(struct comm_reply *repinfo)
2924 {
2925         struct sldns_buffer* buffer;
2926         log_assert(repinfo && repinfo->c);
2927 #ifdef USE_DNSCRYPT
2928         buffer = repinfo->c->dnscrypt_buffer;
2929         if(!dnsc_handle_uncurved_request(repinfo)) {
2930                 return;
2931         }
2932 #else
2933         buffer = repinfo->c->buffer;
2934 #endif
2935         if(repinfo->c->type == comm_udp) {
2936                 if(repinfo->srctype)
2937                         comm_point_send_udp_msg_if(repinfo->c,
2938                         buffer, (struct sockaddr*)&repinfo->addr,
2939                         repinfo->addrlen, repinfo);
2940                 else
2941                         comm_point_send_udp_msg(repinfo->c, buffer,
2942                         (struct sockaddr*)&repinfo->addr, repinfo->addrlen);
2943 #ifdef USE_DNSTAP
2944                 if(repinfo->c->dtenv != NULL &&
2945                    repinfo->c->dtenv->log_client_response_messages)
2946                         dt_msg_send_client_response(repinfo->c->dtenv,
2947                         &repinfo->addr, repinfo->c->type, repinfo->c->buffer);
2948 #endif
2949         } else {
2950 #ifdef USE_DNSTAP
2951                 if(repinfo->c->tcp_parent->dtenv != NULL &&
2952                    repinfo->c->tcp_parent->dtenv->log_client_response_messages)
2953                         dt_msg_send_client_response(repinfo->c->tcp_parent->dtenv,
2954                         &repinfo->addr, repinfo->c->type, repinfo->c->buffer);
2955 #endif
2956                 comm_point_start_listening(repinfo->c, -1,
2957                         repinfo->c->tcp_timeout_msec);
2958         }
2959 }
2960
2961 void
2962 comm_point_drop_reply(struct comm_reply* repinfo)
2963 {
2964         if(!repinfo)
2965                 return;
2966         log_assert(repinfo && repinfo->c);
2967         log_assert(repinfo->c->type != comm_tcp_accept);
2968         if(repinfo->c->type == comm_udp)
2969                 return;
2970         reclaim_tcp_handler(repinfo->c);
2971 }
2972
2973 void
2974 comm_point_stop_listening(struct comm_point* c)
2975 {
2976         verbose(VERB_ALGO, "comm point stop listening %d", c->fd);
2977         if(ub_event_del(c->ev->ev) != 0) {
2978                 log_err("event_del error to stoplisten");
2979         }
2980 }
2981
2982 void
2983 comm_point_start_listening(struct comm_point* c, int newfd, int msec)
2984 {
2985         verbose(VERB_ALGO, "comm point start listening %d",
2986                 c->fd==-1?newfd:c->fd);
2987         if(c->type == comm_tcp_accept && !c->tcp_free) {
2988                 /* no use to start listening no free slots. */
2989                 return;
2990         }
2991         if(msec != -1 && msec != 0) {
2992                 if(!c->timeout) {
2993                         c->timeout = (struct timeval*)malloc(sizeof(
2994                                 struct timeval));
2995                         if(!c->timeout) {
2996                                 log_err("cpsl: malloc failed. No net read.");
2997                                 return;
2998                         }
2999                 }
3000                 ub_event_add_bits(c->ev->ev, UB_EV_TIMEOUT);
3001 #ifndef S_SPLINT_S /* splint fails on struct timeval. */
3002                 c->timeout->tv_sec = msec/1000;
3003                 c->timeout->tv_usec = (msec%1000)*1000;
3004 #endif /* S_SPLINT_S */
3005         }
3006         if(c->type == comm_tcp || c->type == comm_http) {
3007                 ub_event_del_bits(c->ev->ev, UB_EV_READ|UB_EV_WRITE);
3008                 if(c->tcp_is_reading)
3009                         ub_event_add_bits(c->ev->ev, UB_EV_READ);
3010                 else    ub_event_add_bits(c->ev->ev, UB_EV_WRITE);
3011         }
3012         if(newfd != -1) {
3013                 if(c->fd != -1) {
3014 #ifndef USE_WINSOCK
3015                         close(c->fd);
3016 #else
3017                         closesocket(c->fd);
3018 #endif
3019                 }
3020                 c->fd = newfd;
3021                 ub_event_set_fd(c->ev->ev, c->fd);
3022         }
3023         if(ub_event_add(c->ev->ev, msec==0?NULL:c->timeout) != 0) {
3024                 log_err("event_add failed. in cpsl.");
3025         }
3026 }
3027
3028 void comm_point_listen_for_rw(struct comm_point* c, int rd, int wr)
3029 {
3030         verbose(VERB_ALGO, "comm point listen_for_rw %d %d", c->fd, wr);
3031         if(ub_event_del(c->ev->ev) != 0) {
3032                 log_err("event_del error to cplf");
3033         }
3034         ub_event_del_bits(c->ev->ev, UB_EV_READ|UB_EV_WRITE);
3035         if(rd) ub_event_add_bits(c->ev->ev, UB_EV_READ);
3036         if(wr) ub_event_add_bits(c->ev->ev, UB_EV_WRITE);
3037         if(ub_event_add(c->ev->ev, c->timeout) != 0) {
3038                 log_err("event_add failed. in cplf.");
3039         }
3040 }
3041
3042 size_t comm_point_get_mem(struct comm_point* c)
3043 {
3044         size_t s;
3045         if(!c)
3046                 return 0;
3047         s = sizeof(*c) + sizeof(*c->ev);
3048         if(c->timeout)
3049                 s += sizeof(*c->timeout);
3050         if(c->type == comm_tcp || c->type == comm_local) {
3051                 s += sizeof(*c->buffer) + sldns_buffer_capacity(c->buffer);
3052 #ifdef USE_DNSCRYPT
3053                 s += sizeof(*c->dnscrypt_buffer);
3054                 if(c->buffer != c->dnscrypt_buffer) {
3055                         s += sldns_buffer_capacity(c->dnscrypt_buffer);
3056                 }
3057 #endif
3058         }
3059         if(c->type == comm_tcp_accept) {
3060                 int i;
3061                 for(i=0; i<c->max_tcp_count; i++)
3062                         s += comm_point_get_mem(c->tcp_handlers[i]);
3063         }
3064         return s;
3065 }
3066
3067 struct comm_timer*
3068 comm_timer_create(struct comm_base* base, void (*cb)(void*), void* cb_arg)
3069 {
3070         struct internal_timer *tm = (struct internal_timer*)calloc(1,
3071                 sizeof(struct internal_timer));
3072         if(!tm) {
3073                 log_err("malloc failed");
3074                 return NULL;
3075         }
3076         tm->super.ev_timer = tm;
3077         tm->base = base;
3078         tm->super.callback = cb;
3079         tm->super.cb_arg = cb_arg;
3080         tm->ev = ub_event_new(base->eb->base, -1, UB_EV_TIMEOUT,
3081                 comm_timer_callback, &tm->super);
3082         if(tm->ev == NULL) {
3083                 log_err("timer_create: event_base_set failed.");
3084                 free(tm);
3085                 return NULL;
3086         }
3087         return &tm->super;
3088 }
3089
3090 void
3091 comm_timer_disable(struct comm_timer* timer)
3092 {
3093         if(!timer)
3094                 return;
3095         ub_timer_del(timer->ev_timer->ev);
3096         timer->ev_timer->enabled = 0;
3097 }
3098
3099 void
3100 comm_timer_set(struct comm_timer* timer, struct timeval* tv)
3101 {
3102         log_assert(tv);
3103         if(timer->ev_timer->enabled)
3104                 comm_timer_disable(timer);
3105         if(ub_timer_add(timer->ev_timer->ev, timer->ev_timer->base->eb->base,
3106                 comm_timer_callback, timer, tv) != 0)
3107                 log_err("comm_timer_set: evtimer_add failed.");
3108         timer->ev_timer->enabled = 1;
3109 }
3110
3111 void
3112 comm_timer_delete(struct comm_timer* timer)
3113 {
3114         if(!timer)
3115                 return;
3116         comm_timer_disable(timer);
3117         /* Free the sub struct timer->ev_timer derived from the super struct timer.
3118          * i.e. assert(timer == timer->ev_timer)
3119          */
3120         ub_event_free(timer->ev_timer->ev);
3121         free(timer->ev_timer);
3122 }
3123
3124 void
3125 comm_timer_callback(int ATTR_UNUSED(fd), short event, void* arg)
3126 {
3127         struct comm_timer* tm = (struct comm_timer*)arg;
3128         if(!(event&UB_EV_TIMEOUT))
3129                 return;
3130         ub_comm_base_now(tm->ev_timer->base);
3131         tm->ev_timer->enabled = 0;
3132         fptr_ok(fptr_whitelist_comm_timer(tm->callback));
3133         (*tm->callback)(tm->cb_arg);
3134 }
3135
3136 int
3137 comm_timer_is_set(struct comm_timer* timer)
3138 {
3139         return (int)timer->ev_timer->enabled;
3140 }
3141
3142 size_t
3143 comm_timer_get_mem(struct comm_timer* ATTR_UNUSED(timer))
3144 {
3145         return sizeof(struct internal_timer);
3146 }
3147
3148 struct comm_signal*
3149 comm_signal_create(struct comm_base* base,
3150         void (*callback)(int, void*), void* cb_arg)
3151 {
3152         struct comm_signal* com = (struct comm_signal*)malloc(
3153                 sizeof(struct comm_signal));
3154         if(!com) {
3155                 log_err("malloc failed");
3156                 return NULL;
3157         }
3158         com->base = base;
3159         com->callback = callback;
3160         com->cb_arg = cb_arg;
3161         com->ev_signal = NULL;
3162         return com;
3163 }
3164
3165 void
3166 comm_signal_callback(int sig, short event, void* arg)
3167 {
3168         struct comm_signal* comsig = (struct comm_signal*)arg;
3169         if(!(event & UB_EV_SIGNAL))
3170                 return;
3171         ub_comm_base_now(comsig->base);
3172         fptr_ok(fptr_whitelist_comm_signal(comsig->callback));
3173         (*comsig->callback)(sig, comsig->cb_arg);
3174 }
3175
3176 int
3177 comm_signal_bind(struct comm_signal* comsig, int sig)
3178 {
3179         struct internal_signal* entry = (struct internal_signal*)calloc(1,
3180                 sizeof(struct internal_signal));
3181         if(!entry) {
3182                 log_err("malloc failed");
3183                 return 0;
3184         }
3185         log_assert(comsig);
3186         /* add signal event */
3187         entry->ev = ub_signal_new(comsig->base->eb->base, sig,
3188                 comm_signal_callback, comsig);
3189         if(entry->ev == NULL) {
3190                 log_err("Could not create signal event");
3191                 free(entry);
3192                 return 0;
3193         }
3194         if(ub_signal_add(entry->ev, NULL) != 0) {
3195                 log_err("Could not add signal handler");
3196                 ub_event_free(entry->ev);
3197                 free(entry);
3198                 return 0;
3199         }
3200         /* link into list */
3201         entry->next = comsig->ev_signal;
3202         comsig->ev_signal = entry;
3203         return 1;
3204 }
3205
3206 void
3207 comm_signal_delete(struct comm_signal* comsig)
3208 {
3209         struct internal_signal* p, *np;
3210         if(!comsig)
3211                 return;
3212         p=comsig->ev_signal;
3213         while(p) {
3214                 np = p->next;
3215                 ub_signal_del(p->ev);
3216                 ub_event_free(p->ev);
3217                 free(p);
3218                 p = np;
3219         }
3220         free(comsig);
3221 }