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