contrib/unbound/util/netevent.c

   1 /*
   2  * util/netevent.c - event notification
   3  *
   4  * Copyright (c) 2007, NLnet Labs. All rights reserved.
   5  *
   6  * This software is open source.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  *
  12  * Redistributions of source code must retain the above copyright notice,
  13  * this list of conditions and the following disclaimer.
  14  *
  15  * Redistributions in binary form must reproduce the above copyright notice,
  16  * this list of conditions and the following disclaimer in the documentation
  17  * and/or other materials provided with the distribution.
  18  *
  19  * Neither the name of the NLNET LABS nor the names of its contributors may
  20  * be used to endorse or promote products derived from this software without
  21  * specific prior written permission.
  22  *
  23  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  24  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  25  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  26  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  27  * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  28  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
  29  * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  30  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  31  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  32  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  33  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  34  */
  35
  36 /**
  37  * \file
  38  *
  39  * This file contains event notification functions.
  40  */
  41 #include "config.h"
  42 #include "util/netevent.h"
  43 #include "util/log.h"
  44 #include "util/net_help.h"
  45 #include "util/fptr_wlist.h"
  46 #include "ldns/pkthdr.h"
  47 #include "ldns/sbuffer.h"
  48 #ifdef HAVE_OPENSSL_SSL_H
  49 #include <openssl/ssl.h>
  50 #endif
  51 #ifdef HAVE_OPENSSL_ERR_H
  52 #include <openssl/err.h>
  53 #endif
  54
  55 /* -------- Start of local definitions -------- */
  56 /** if CMSG_ALIGN is not defined on this platform, a workaround */
  57 #ifndef CMSG_ALIGN
  58 #  ifdef _CMSG_DATA_ALIGN
  59 #    define CMSG_ALIGN _CMSG_DATA_ALIGN
  60 #  else
  61 #    define CMSG_ALIGN(len) (((len)+sizeof(long)-1) & ~(sizeof(long)-1))
  62 #  endif
  63 #endif
  64
  65 /** if CMSG_LEN is not defined on this platform, a workaround */
  66 #ifndef CMSG_LEN
  67 #  define CMSG_LEN(len) (CMSG_ALIGN(sizeof(struct cmsghdr))+(len))
  68 #endif
  69
  70 /** if CMSG_SPACE is not defined on this platform, a workaround */
  71 #ifndef CMSG_SPACE
  72 #  ifdef _CMSG_HDR_ALIGN
  73 #    define CMSG_SPACE(l) (CMSG_ALIGN(l)+_CMSG_HDR_ALIGN(sizeof(struct cmsghdr)))
  74 #  else
  75 #    define CMSG_SPACE(l) (CMSG_ALIGN(l)+CMSG_ALIGN(sizeof(struct cmsghdr)))
  76 #  endif
  77 #endif
  78
  79 /** The TCP reading or writing query timeout in seconds */
  80 #define TCP_QUERY_TIMEOUT 120
  81
  82 #ifndef NONBLOCKING_IS_BROKEN
  83 /** number of UDP reads to perform per read indication from select */
  84 #define NUM_UDP_PER_SELECT 100
  85 #else
  86 #define NUM_UDP_PER_SELECT 1
  87 #endif
  88
  89 /* We define libevent structures here to hide the libevent stuff. */
  90
  91 #ifdef USE_MINI_EVENT
  92 #  ifdef USE_WINSOCK
  93 #    include "util/winsock_event.h"
  94 #  else
  95 #    include "util/mini_event.h"
  96 #  endif /* USE_WINSOCK */
  97 #else /* USE_MINI_EVENT */
  98    /* we use libevent */
  99 #  ifdef HAVE_EVENT_H
 100 #    include <event.h>
 101 #  else
 102 #    include "event2/event.h"
 103 #    include "event2/event_struct.h"
 104 #    include "event2/event_compat.h"
 105 #  endif
 106 #endif /* USE_MINI_EVENT */
 107
 108 /**
 109  * The internal event structure for keeping libevent info for the event.
 110  * Possibly other structures (list, tree) this is part of.
 111  */
 112 struct internal_event {
 113         /** the comm base */
 114         struct comm_base* base;
 115         /** libevent event type, alloced here */
 116         struct event ev;
 117 };
 118
 119 /**
 120  * Internal base structure, so that every thread has its own events.
 121  */
 122 struct internal_base {
 123         /** libevent event_base type. */
 124         struct event_base* base;
 125         /** seconds time pointer points here */
 126         time_t secs;
 127         /** timeval with current time */
 128         struct timeval now;
 129         /** the event used for slow_accept timeouts */
 130         struct event slow_accept;
 131         /** true if slow_accept is enabled */
 132         int slow_accept_enabled;
 133 };
 134
 135 /**
 136  * Internal timer structure, to store timer event in.
 137  */
 138 struct internal_timer {
 139         /** the comm base */
 140         struct comm_base* base;
 141         /** libevent event type, alloced here */
 142         struct event ev;
 143         /** is timer enabled */
 144         uint8_t enabled;
 145 };
 146
 147 /**
 148  * Internal signal structure, to store signal event in.
 149  */
 150 struct internal_signal {
 151         /** libevent event type, alloced here */
 152         struct event ev;
 153         /** next in signal list */
 154         struct internal_signal* next;
 155 };
 156
 157 /** create a tcp handler with a parent */
 158 static struct comm_point* comm_point_create_tcp_handler(
 159         struct comm_base *base, struct comm_point* parent, size_t bufsize,
 160         comm_point_callback_t* callback, void* callback_arg);
 161
 162 /* -------- End of local definitions -------- */
 163
 164 #ifdef USE_MINI_EVENT
 165 /** minievent updates the time when it blocks. */
 166 #define comm_base_now(x) /* nothing to do */
 167 #else /* !USE_MINI_EVENT */
 168 /** fillup the time values in the event base */
 169 static void
 170 comm_base_now(struct comm_base* b)
 171 {
 172         if(gettimeofday(&b->eb->now, NULL) < 0) {
 173                 log_err("gettimeofday: %s", strerror(errno));
 174         }
 175         b->eb->secs = (time_t)b->eb->now.tv_sec;
 176 }
 177 #endif /* USE_MINI_EVENT */
 178
 179 struct comm_base*
 180 comm_base_create(int sigs)
 181 {
 182         struct comm_base* b = (struct comm_base*)calloc(1,
 183                 sizeof(struct comm_base));
 184         if(!b)
 185                 return NULL;
 186         b->eb = (struct internal_base*)calloc(1, sizeof(struct internal_base));
 187         if(!b->eb) {
 188                 free(b);
 189                 return NULL;
 190         }
 191 #ifdef USE_MINI_EVENT
 192         (void)sigs;
 193         /* use mini event time-sharing feature */
 194         b->eb->base = event_init(&b->eb->secs, &b->eb->now);
 195 #else
 196 #  if defined(HAVE_EV_LOOP) || defined(HAVE_EV_DEFAULT_LOOP)
 197         /* libev */
 198         if(sigs)
 199                 b->eb->base=(struct event_base *)ev_default_loop(EVFLAG_AUTO);
 200         else
 201                 b->eb->base=(struct event_base *)ev_loop_new(EVFLAG_AUTO);
 202 #  else
 203         (void)sigs;
 204 #    ifdef HAVE_EVENT_BASE_NEW
 205         b->eb->base = event_base_new();
 206 #    else
 207         b->eb->base = event_init();
 208 #    endif
 209 #  endif
 210 #endif
 211         if(!b->eb->base) {
 212                 free(b->eb);
 213                 free(b);
 214                 return NULL;
 215         }
 216         comm_base_now(b);
 217         /* avoid event_get_method call which causes crashes even when
 218          * not printing, because its result is passed */
 219         verbose(VERB_ALGO,
 220 #if defined(HAVE_EV_LOOP) || defined(HAVE_EV_DEFAULT_LOOP)
 221                 "libev"
 222 #elif defined(USE_MINI_EVENT)
 223                 "event "
 224 #else
 225                 "libevent "
 226 #endif
 227                 "%s uses %s method.",
 228                 event_get_version(),
 229 #ifdef HAVE_EVENT_BASE_GET_METHOD
 230                 event_base_get_method(b->eb->base)
 231 #else
 232                 "not_obtainable"
 233 #endif
 234         );
 235         return b;
 236 }
 237
 238 struct comm_base*
 239 comm_base_create_event(struct event_base* base)
 240 {
 241         struct comm_base* b = (struct comm_base*)calloc(1,
 242                 sizeof(struct comm_base));
 243         if(!b)
 244                 return NULL;
 245         b->eb = (struct internal_base*)calloc(1, sizeof(struct internal_base));
 246         if(!b->eb) {
 247                 free(b);
 248                 return NULL;
 249         }
 250         b->eb->base = base;
 251         comm_base_now(b);
 252         return b;
 253 }
 254
 255 void
 256 comm_base_delete(struct comm_base* b)
 257 {
 258         if(!b)
 259                 return;
 260         if(b->eb->slow_accept_enabled) {
 261                 if(event_del(&b->eb->slow_accept) != 0) {
 262                         log_err("could not event_del slow_accept");
 263                 }
 264         }
 265 #ifdef USE_MINI_EVENT
 266         event_base_free(b->eb->base);
 267 #elif defined(HAVE_EVENT_BASE_FREE) && defined(HAVE_EVENT_BASE_ONCE)
 268         /* only libevent 1.2+ has it, but in 1.2 it is broken -
 269            assertion fails on signal handling ev that is not deleted
 270            in libevent 1.3c (event_base_once appears) this is fixed. */
 271         event_base_free(b->eb->base);
 272 #endif /* HAVE_EVENT_BASE_FREE and HAVE_EVENT_BASE_ONCE */
 273         b->eb->base = NULL;
 274         free(b->eb);
 275         free(b);
 276 }
 277
 278 void
 279 comm_base_delete_no_base(struct comm_base* b)
 280 {
 281         if(!b)
 282                 return;
 283         if(b->eb->slow_accept_enabled) {
 284                 if(event_del(&b->eb->slow_accept) != 0) {
 285                         log_err("could not event_del slow_accept");
 286                 }
 287         }
 288         b->eb->base = NULL;
 289         free(b->eb);
 290         free(b);
 291 }
 292
 293 void
 294 comm_base_timept(struct comm_base* b, time_t** tt, struct timeval** tv)
 295 {
 296         *tt = &b->eb->secs;
 297         *tv = &b->eb->now;
 298 }
 299
 300 void
 301 comm_base_dispatch(struct comm_base* b)
 302 {
 303         int retval;
 304         retval = event_base_dispatch(b->eb->base);
 305         if(retval != 0) {
 306                 fatal_exit("event_dispatch returned error %d, "
 307                         "errno is %s", retval, strerror(errno));
 308         }
 309 }
 310
 311 void comm_base_exit(struct comm_base* b)
 312 {
 313         if(event_base_loopexit(b->eb->base, NULL) != 0) {
 314                 log_err("Could not loopexit");
 315         }
 316 }
 317
 318 void comm_base_set_slow_accept_handlers(struct comm_base* b,
 319         void (*stop_acc)(void*), void (*start_acc)(void*), void* arg)
 320 {
 321         b->stop_accept = stop_acc;
 322         b->start_accept = start_acc;
 323         b->cb_arg = arg;
 324 }
 325
 326 struct event_base* comm_base_internal(struct comm_base* b)
 327 {
 328         return b->eb->base;
 329 }
 330
 331 /** see if errno for udp has to be logged or not uses globals */
 332 static int
 333 udp_send_errno_needs_log(struct sockaddr* addr, socklen_t addrlen)
 334 {
 335         /* do not log transient errors (unless high verbosity) */
 336 #if defined(ENETUNREACH) || defined(EHOSTDOWN) || defined(EHOSTUNREACH) || defined(ENETDOWN)
 337         switch(errno) {
 338 #  ifdef ENETUNREACH
 339                 case ENETUNREACH:
 340 #  endif
 341 #  ifdef EHOSTDOWN
 342                 case EHOSTDOWN:
 343 #  endif
 344 #  ifdef EHOSTUNREACH
 345                 case EHOSTUNREACH:
 346 #  endif
 347 #  ifdef ENETDOWN
 348                 case ENETDOWN:
 349 #  endif
 350                         if(verbosity < VERB_ALGO)
 351                                 return 0;
 352                 default:
 353                         break;
 354         }
 355 #endif
 356         /* permission denied is gotten for every send if the
 357          * network is disconnected (on some OS), squelch it */
 358         if(errno == EPERM && verbosity < VERB_DETAIL)
 359                 return 0;
 360         /* squelch errors where people deploy AAAA ::ffff:bla for
 361          * authority servers, which we try for intranets. */
 362         if(errno == EINVAL && addr_is_ip4mapped(
 363                 (struct sockaddr_storage*)addr, addrlen) &&
 364                 verbosity < VERB_DETAIL)
 365                 return 0;
 366         /* SO_BROADCAST sockopt can give access to 255.255.255.255,
 367          * but a dns cache does not need it. */
 368         if(errno == EACCES && addr_is_broadcast(
 369                 (struct sockaddr_storage*)addr, addrlen) &&
 370                 verbosity < VERB_DETAIL)
 371                 return 0;
 372         return 1;
 373 }
 374
 375 int tcp_connect_errno_needs_log(struct sockaddr* addr, socklen_t addrlen)
 376 {
 377         return udp_send_errno_needs_log(addr, addrlen);
 378 }
 379
 380 /* send a UDP reply */
 381 int
 382 comm_point_send_udp_msg(struct comm_point *c, sldns_buffer* packet,
 383         struct sockaddr* addr, socklen_t addrlen)
 384 {
 385         ssize_t sent;
 386         log_assert(c->fd != -1);
 387 #ifdef UNBOUND_DEBUG
 388         if(sldns_buffer_remaining(packet) == 0)
 389                 log_err("error: send empty UDP packet");
 390 #endif
 391         log_assert(addr && addrlen > 0);
 392         sent = sendto(c->fd, (void*)sldns_buffer_begin(packet),
 393                 sldns_buffer_remaining(packet), 0,
 394                 addr, addrlen);
 395         if(sent == -1) {
 396                 if(!udp_send_errno_needs_log(addr, addrlen))
 397                         return 0;
 398 #ifndef USE_WINSOCK
 399                 verbose(VERB_OPS, "sendto failed: %s", strerror(errno));
 400 #else
 401                 verbose(VERB_OPS, "sendto failed: %s",
 402                         wsa_strerror(WSAGetLastError()));
 403 #endif
 404                 log_addr(VERB_OPS, "remote address is",
 405                         (struct sockaddr_storage*)addr, addrlen);
 406                 return 0;
 407         } else if((size_t)sent != sldns_buffer_remaining(packet)) {
 408                 log_err("sent %d in place of %d bytes",
 409                         (int)sent, (int)sldns_buffer_remaining(packet));
 410                 return 0;
 411         }
 412         return 1;
 413 }
 414
 415 #if defined(AF_INET6) && defined(IPV6_PKTINFO) && (defined(HAVE_RECVMSG) || defined(HAVE_SENDMSG))
 416 /** print debug ancillary info */
 417 static void p_ancil(const char* str, struct comm_reply* r)
 418 {
 419         if(r->srctype != 4 && r->srctype != 6) {
 420                 log_info("%s: unknown srctype %d", str, r->srctype);
 421                 return;
 422         }
 423         if(r->srctype == 6) {
 424                 char buf[1024];
 425                 if(inet_ntop(AF_INET6, &r->pktinfo.v6info.ipi6_addr,
 426                         buf, (socklen_t)sizeof(buf)) == 0) {
 427                         (void)strlcpy(buf, "(inet_ntop error)", sizeof(buf));
 428                 }
 429                 buf[sizeof(buf)-1]=0;
 430                 log_info("%s: %s %d", str, buf, r->pktinfo.v6info.ipi6_ifindex);
 431         } else if(r->srctype == 4) {
 432 #ifdef IP_PKTINFO
 433                 char buf1[1024], buf2[1024];
 434                 if(inet_ntop(AF_INET, &r->pktinfo.v4info.ipi_addr,
 435                         buf1, (socklen_t)sizeof(buf1)) == 0) {
 436                         (void)strlcpy(buf1, "(inet_ntop error)", sizeof(buf1));
 437                 }
 438                 buf1[sizeof(buf1)-1]=0;
 439 #ifdef HAVE_STRUCT_IN_PKTINFO_IPI_SPEC_DST
 440                 if(inet_ntop(AF_INET, &r->pktinfo.v4info.ipi_spec_dst,
 441                         buf2, (socklen_t)sizeof(buf2)) == 0) {
 442                         (void)strlcpy(buf2, "(inet_ntop error)", sizeof(buf2));
 443                 }
 444                 buf2[sizeof(buf2)-1]=0;
 445 #else
 446                 buf2[0]=0;
 447 #endif
 448                 log_info("%s: %d %s %s", str, r->pktinfo.v4info.ipi_ifindex,
 449                         buf1, buf2);
 450 #elif defined(IP_RECVDSTADDR)
 451                 char buf1[1024];
 452                 if(inet_ntop(AF_INET, &r->pktinfo.v4addr,
 453                         buf1, (socklen_t)sizeof(buf1)) == 0) {
 454                         (void)strlcpy(buf1, "(inet_ntop error)", sizeof(buf1));
 455                 }
 456                 buf1[sizeof(buf1)-1]=0;
 457                 log_info("%s: %s", str, buf1);
 458 #endif /* IP_PKTINFO or PI_RECVDSTDADDR */
 459         }
 460 }
 461 #endif /* AF_INET6 && IPV6_PKTINFO && HAVE_RECVMSG||HAVE_SENDMSG */
 462
 463 /** send a UDP reply over specified interface*/
 464 static int
 465 comm_point_send_udp_msg_if(struct comm_point *c, sldns_buffer* packet,
 466         struct sockaddr* addr, socklen_t addrlen, struct comm_reply* r)
 467 {
 468 #if defined(AF_INET6) && defined(IPV6_PKTINFO) && defined(HAVE_SENDMSG)
 469         ssize_t sent;
 470         struct msghdr msg;
 471         struct iovec iov[1];
 472         char control[256];
 473 #ifndef S_SPLINT_S
 474         struct cmsghdr *cmsg;
 475 #endif /* S_SPLINT_S */
 476
 477         log_assert(c->fd != -1);
 478 #ifdef UNBOUND_DEBUG
 479         if(sldns_buffer_remaining(packet) == 0)
 480                 log_err("error: send empty UDP packet");
 481 #endif
 482         log_assert(addr && addrlen > 0);
 483
 484         msg.msg_name = addr;
 485         msg.msg_namelen = addrlen;
 486         iov[0].iov_base = sldns_buffer_begin(packet);
 487         iov[0].iov_len = sldns_buffer_remaining(packet);
 488         msg.msg_iov = iov;
 489         msg.msg_iovlen = 1;
 490         msg.msg_control = control;
 491 #ifndef S_SPLINT_S
 492         msg.msg_controllen = sizeof(control);
 493 #endif /* S_SPLINT_S */
 494         msg.msg_flags = 0;
 495
 496 #ifndef S_SPLINT_S
 497         cmsg = CMSG_FIRSTHDR(&msg);
 498         if(r->srctype == 4) {
 499 #ifdef IP_PKTINFO
 500                 msg.msg_controllen = CMSG_SPACE(sizeof(struct in_pktinfo));
 501                 log_assert(msg.msg_controllen <= sizeof(control));
 502                 cmsg->cmsg_level = IPPROTO_IP;
 503                 cmsg->cmsg_type = IP_PKTINFO;
 504                 memmove(CMSG_DATA(cmsg), &r->pktinfo.v4info,
 505                         sizeof(struct in_pktinfo));
 506                 cmsg->cmsg_len = CMSG_LEN(sizeof(struct in_pktinfo));
 507 #elif defined(IP_SENDSRCADDR)
 508                 msg.msg_controllen = CMSG_SPACE(sizeof(struct in_addr));
 509                 log_assert(msg.msg_controllen <= sizeof(control));
 510                 cmsg->cmsg_level = IPPROTO_IP;
 511                 cmsg->cmsg_type = IP_SENDSRCADDR;
 512                 memmove(CMSG_DATA(cmsg), &r->pktinfo.v4addr,
 513                         sizeof(struct in_addr));
 514                 cmsg->cmsg_len = CMSG_LEN(sizeof(struct in_addr));
 515 #else
 516                 verbose(VERB_ALGO, "no IP_PKTINFO or IP_SENDSRCADDR");
 517                 msg.msg_control = NULL;
 518 #endif /* IP_PKTINFO or IP_SENDSRCADDR */
 519         } else if(r->srctype == 6) {
 520                 msg.msg_controllen = CMSG_SPACE(sizeof(struct in6_pktinfo));
 521                 log_assert(msg.msg_controllen <= sizeof(control));
 522                 cmsg->cmsg_level = IPPROTO_IPV6;
 523                 cmsg->cmsg_type = IPV6_PKTINFO;
 524                 memmove(CMSG_DATA(cmsg), &r->pktinfo.v6info,
 525                         sizeof(struct in6_pktinfo));
 526                 cmsg->cmsg_len = CMSG_LEN(sizeof(struct in6_pktinfo));
 527         } else {
 528                 /* try to pass all 0 to use default route */
 529                 msg.msg_controllen = CMSG_SPACE(sizeof(struct in6_pktinfo));
 530                 log_assert(msg.msg_controllen <= sizeof(control));
 531                 cmsg->cmsg_level = IPPROTO_IPV6;
 532                 cmsg->cmsg_type = IPV6_PKTINFO;
 533                 memset(CMSG_DATA(cmsg), 0, sizeof(struct in6_pktinfo));
 534                 cmsg->cmsg_len = CMSG_LEN(sizeof(struct in6_pktinfo));
 535         }
 536 #endif /* S_SPLINT_S */
 537         if(verbosity >= VERB_ALGO)
 538                 p_ancil("send_udp over interface", r);
 539         sent = sendmsg(c->fd, &msg, 0);
 540         if(sent == -1) {
 541                 if(!udp_send_errno_needs_log(addr, addrlen))
 542                         return 0;
 543                 verbose(VERB_OPS, "sendmsg failed: %s", strerror(errno));
 544                 log_addr(VERB_OPS, "remote address is",
 545                         (struct sockaddr_storage*)addr, addrlen);
 546                 return 0;
 547         } else if((size_t)sent != sldns_buffer_remaining(packet)) {
 548                 log_err("sent %d in place of %d bytes",
 549                         (int)sent, (int)sldns_buffer_remaining(packet));
 550                 return 0;
 551         }
 552         return 1;
 553 #else
 554         (void)c;
 555         (void)packet;
 556         (void)addr;
 557         (void)addrlen;
 558         (void)r;
 559         log_err("sendmsg: IPV6_PKTINFO not supported");
 560         return 0;
 561 #endif /* AF_INET6 && IPV6_PKTINFO && HAVE_SENDMSG */
 562 }
 563
 564 void
 565 comm_point_udp_ancil_callback(int fd, short event, void* arg)
 566 {
 567 #if defined(AF_INET6) && defined(IPV6_PKTINFO) && defined(HAVE_RECVMSG)
 568         struct comm_reply rep;
 569         struct msghdr msg;
 570         struct iovec iov[1];
 571         ssize_t rcv;
 572         char ancil[256];
 573         int i;
 574 #ifndef S_SPLINT_S
 575         struct cmsghdr* cmsg;
 576 #endif /* S_SPLINT_S */
 577
 578         rep.c = (struct comm_point*)arg;
 579         log_assert(rep.c->type == comm_udp);
 580
 581         if(!(event&EV_READ))
 582                 return;
 583         log_assert(rep.c && rep.c->buffer && rep.c->fd == fd);
 584         comm_base_now(rep.c->ev->base);
 585         for(i=0; i<NUM_UDP_PER_SELECT; i++) {
 586                 sldns_buffer_clear(rep.c->buffer);
 587                 rep.addrlen = (socklen_t)sizeof(rep.addr);
 588                 log_assert(fd != -1);
 589                 log_assert(sldns_buffer_remaining(rep.c->buffer) > 0);
 590                 msg.msg_name = &rep.addr;
 591                 msg.msg_namelen = (socklen_t)sizeof(rep.addr);
 592                 iov[0].iov_base = sldns_buffer_begin(rep.c->buffer);
 593                 iov[0].iov_len = sldns_buffer_remaining(rep.c->buffer);
 594                 msg.msg_iov = iov;
 595                 msg.msg_iovlen = 1;
 596                 msg.msg_control = ancil;
 597 #ifndef S_SPLINT_S
 598                 msg.msg_controllen = sizeof(ancil);
 599 #endif /* S_SPLINT_S */
 600                 msg.msg_flags = 0;
 601                 rcv = recvmsg(fd, &msg, 0);
 602                 if(rcv == -1) {
 603                         if(errno != EAGAIN && errno != EINTR) {
 604                                 log_err("recvmsg failed: %s", strerror(errno));
 605                         }
 606                         return;
 607                 }
 608                 rep.addrlen = msg.msg_namelen;
 609                 sldns_buffer_skip(rep.c->buffer, rcv);
 610                 sldns_buffer_flip(rep.c->buffer);
 611                 rep.srctype = 0;
 612 #ifndef S_SPLINT_S
 613                 for(cmsg = CMSG_FIRSTHDR(&msg); cmsg != NULL;
 614                         cmsg = CMSG_NXTHDR(&msg, cmsg)) {
 615                         if( cmsg->cmsg_level == IPPROTO_IPV6 &&
 616                                 cmsg->cmsg_type == IPV6_PKTINFO) {
 617                                 rep.srctype = 6;
 618                                 memmove(&rep.pktinfo.v6info, CMSG_DATA(cmsg),
 619                                         sizeof(struct in6_pktinfo));
 620                                 break;
 621 #ifdef IP_PKTINFO
 622                         } else if( cmsg->cmsg_level == IPPROTO_IP &&
 623                                 cmsg->cmsg_type == IP_PKTINFO) {
 624                                 rep.srctype = 4;
 625                                 memmove(&rep.pktinfo.v4info, CMSG_DATA(cmsg),
 626                                         sizeof(struct in_pktinfo));
 627                                 break;
 628 #elif defined(IP_RECVDSTADDR)
 629                         } else if( cmsg->cmsg_level == IPPROTO_IP &&
 630                                 cmsg->cmsg_type == IP_RECVDSTADDR) {
 631                                 rep.srctype = 4;
 632                                 memmove(&rep.pktinfo.v4addr, CMSG_DATA(cmsg),
 633                                         sizeof(struct in_addr));
 634                                 break;
 635 #endif /* IP_PKTINFO or IP_RECVDSTADDR */
 636                         }
 637                 }
 638                 if(verbosity >= VERB_ALGO)
 639                         p_ancil("receive_udp on interface", &rep);
 640 #endif /* S_SPLINT_S */
 641                 fptr_ok(fptr_whitelist_comm_point(rep.c->callback));
 642                 if((*rep.c->callback)(rep.c, rep.c->cb_arg, NETEVENT_NOERROR, &rep)) {
 643                         /* send back immediate reply */
 644                         (void)comm_point_send_udp_msg_if(rep.c, rep.c->buffer,
 645                                 (struct sockaddr*)&rep.addr, rep.addrlen, &rep);
 646                 }
 647                 if(rep.c->fd == -1) /* commpoint closed */
 648                         break;
 649         }
 650 #else
 651         (void)fd;
 652         (void)event;
 653         (void)arg;
 654         fatal_exit("recvmsg: No support for IPV6_PKTINFO. "
 655                 "Please disable interface-automatic");
 656 #endif /* AF_INET6 && IPV6_PKTINFO && HAVE_RECVMSG */
 657 }
 658
 659 void
 660 comm_point_udp_callback(int fd, short event, void* arg)
 661 {
 662         struct comm_reply rep;
 663         ssize_t rcv;
 664         int i;
 665
 666         rep.c = (struct comm_point*)arg;
 667         log_assert(rep.c->type == comm_udp);
 668
 669         if(!(event&EV_READ))
 670                 return;
 671         log_assert(rep.c && rep.c->buffer && rep.c->fd == fd);
 672         comm_base_now(rep.c->ev->base);
 673         for(i=0; i<NUM_UDP_PER_SELECT; i++) {
 674                 sldns_buffer_clear(rep.c->buffer);
 675                 rep.addrlen = (socklen_t)sizeof(rep.addr);
 676                 log_assert(fd != -1);
 677                 log_assert(sldns_buffer_remaining(rep.c->buffer) > 0);
 678                 rcv = recvfrom(fd, (void*)sldns_buffer_begin(rep.c->buffer),
 679                         sldns_buffer_remaining(rep.c->buffer), 0,
 680                         (struct sockaddr*)&rep.addr, &rep.addrlen);
 681                 if(rcv == -1) {
 682 #ifndef USE_WINSOCK
 683                         if(errno != EAGAIN && errno != EINTR)
 684                                 log_err("recvfrom %d failed: %s",
 685                                         fd, strerror(errno));
 686 #else
 687                         if(WSAGetLastError() != WSAEINPROGRESS &&
 688                                 WSAGetLastError() != WSAECONNRESET &&
 689                                 WSAGetLastError()!= WSAEWOULDBLOCK)
 690                                 log_err("recvfrom failed: %s",
 691                                         wsa_strerror(WSAGetLastError()));
 692 #endif
 693                         return;
 694                 }
 695                 sldns_buffer_skip(rep.c->buffer, rcv);
 696                 sldns_buffer_flip(rep.c->buffer);
 697                 rep.srctype = 0;
 698                 fptr_ok(fptr_whitelist_comm_point(rep.c->callback));
 699                 if((*rep.c->callback)(rep.c, rep.c->cb_arg, NETEVENT_NOERROR, &rep)) {
 700                         /* send back immediate reply */
 701                         (void)comm_point_send_udp_msg(rep.c, rep.c->buffer,
 702                                 (struct sockaddr*)&rep.addr, rep.addrlen);
 703                 }
 704                 if(rep.c->fd != fd) /* commpoint closed to -1 or reused for
 705                 another UDP port. Note rep.c cannot be reused with TCP fd. */
 706                         break;
 707         }
 708 }
 709
 710 /** Use a new tcp handler for new query fd, set to read query */
 711 static void
 712 setup_tcp_handler(struct comm_point* c, int fd)
 713 {
 714         log_assert(c->type == comm_tcp);
 715         log_assert(c->fd == -1);
 716         sldns_buffer_clear(c->buffer);
 717         c->tcp_is_reading = 1;
 718         c->tcp_byte_count = 0;
 719         comm_point_start_listening(c, fd, TCP_QUERY_TIMEOUT);
 720 }
 721
 722 void comm_base_handle_slow_accept(int ATTR_UNUSED(fd),
 723         short ATTR_UNUSED(event), void* arg)
 724 {
 725         struct comm_base* b = (struct comm_base*)arg;
 726         /* timeout for the slow accept, re-enable accepts again */
 727         if(b->start_accept) {
 728                 verbose(VERB_ALGO, "wait is over, slow accept disabled");
 729                 fptr_ok(fptr_whitelist_start_accept(b->start_accept));
 730                 (*b->start_accept)(b->cb_arg);
 731                 b->eb->slow_accept_enabled = 0;
 732         }
 733 }
 734
 735 int comm_point_perform_accept(struct comm_point* c,
 736         struct sockaddr_storage* addr, socklen_t* addrlen)
 737 {
 738         int new_fd;
 739         *addrlen = (socklen_t)sizeof(*addr);
 740         new_fd = accept(c->fd, (struct sockaddr*)addr, addrlen);
 741         if(new_fd == -1) {
 742 #ifndef USE_WINSOCK
 743                 /* EINTR is signal interrupt. others are closed connection. */
 744                 if(     errno == EINTR || errno == EAGAIN
 745 #ifdef EWOULDBLOCK
 746                         || errno == EWOULDBLOCK
 747 #endif
 748 #ifdef ECONNABORTED
 749                         || errno == ECONNABORTED
 750 #endif
 751 #ifdef EPROTO
 752                         || errno == EPROTO
 753 #endif /* EPROTO */
 754                         )
 755                         return -1;
 756 #if defined(ENFILE) && defined(EMFILE)
 757                 if(errno == ENFILE || errno == EMFILE) {
 758                         /* out of file descriptors, likely outside of our
 759                          * control. stop accept() calls for some time */
 760                         if(c->ev->base->stop_accept) {
 761                                 struct comm_base* b = c->ev->base;
 762                                 struct timeval tv;
 763                                 verbose(VERB_ALGO, "out of file descriptors: "
 764                                         "slow accept");
 765                                 b->eb->slow_accept_enabled = 1;
 766                                 fptr_ok(fptr_whitelist_stop_accept(
 767                                         b->stop_accept));
 768                                 (*b->stop_accept)(b->cb_arg);
 769                                 /* set timeout, no mallocs */
 770                                 tv.tv_sec = NETEVENT_SLOW_ACCEPT_TIME/1000;
 771                                 tv.tv_usec = NETEVENT_SLOW_ACCEPT_TIME%1000;
 772                                 event_set(&b->eb->slow_accept, -1, EV_TIMEOUT,
 773                                         comm_base_handle_slow_accept, b);
 774                                 if(event_base_set(b->eb->base,
 775                                         &b->eb->slow_accept) != 0) {
 776                                         /* we do not want to log here, because
 777                                          * that would spam the logfiles.
 778                                          * error: "event_base_set failed." */
 779                                 }
 780                                 if(event_add(&b->eb->slow_accept, &tv) != 0) {
 781                                         /* we do not want to log here,
 782                                          * error: "event_add failed." */
 783                                 }
 784                         }
 785                         return -1;
 786                 }
 787 #endif
 788                 log_err("accept failed: %s", strerror(errno));
 789 #else /* USE_WINSOCK */
 790                 if(WSAGetLastError() == WSAEINPROGRESS ||
 791                         WSAGetLastError() == WSAECONNRESET)
 792                         return -1;
 793                 if(WSAGetLastError() == WSAEWOULDBLOCK) {
 794                         winsock_tcp_wouldblock(&c->ev->ev, EV_READ);
 795                         return -1;
 796                 }
 797                 log_err("accept failed: %s", wsa_strerror(WSAGetLastError()));
 798 #endif
 799                 log_addr(0, "remote address is", addr, *addrlen);
 800                 return -1;
 801         }
 802         fd_set_nonblock(new_fd);
 803         return new_fd;
 804 }
 805
 806 #ifdef USE_WINSOCK
 807 static long win_bio_cb(BIO *b, int oper, const char* ATTR_UNUSED(argp),
 808         int ATTR_UNUSED(argi), long argl, long retvalue)
 809 {
 810         verbose(VERB_ALGO, "bio_cb %d, %s %s %s", oper,
 811                 (oper&BIO_CB_RETURN)?"return":"before",
 812                 (oper&BIO_CB_READ)?"read":((oper&BIO_CB_WRITE)?"write":"other"),
 813                 WSAGetLastError()==WSAEWOULDBLOCK?"wsawb":"");
 814         /* on windows, check if previous operation caused EWOULDBLOCK */
 815         if( (oper == (BIO_CB_READ|BIO_CB_RETURN) && argl == 0) ||
 816                 (oper == (BIO_CB_GETS|BIO_CB_RETURN) && argl == 0)) {
 817                 if(WSAGetLastError() == WSAEWOULDBLOCK)
 818                         winsock_tcp_wouldblock((struct event*)
 819                                 BIO_get_callback_arg(b), EV_READ);
 820         }
 821         if( (oper == (BIO_CB_WRITE|BIO_CB_RETURN) && argl == 0) ||
 822                 (oper == (BIO_CB_PUTS|BIO_CB_RETURN) && argl == 0)) {
 823                 if(WSAGetLastError() == WSAEWOULDBLOCK)
 824                         winsock_tcp_wouldblock((struct event*)
 825                                 BIO_get_callback_arg(b), EV_WRITE);
 826         }
 827         /* return original return value */
 828         return retvalue;
 829 }
 830
 831 /** set win bio callbacks for nonblocking operations */
 832 void
 833 comm_point_tcp_win_bio_cb(struct comm_point* c, void* thessl)
 834 {
 835         SSL* ssl = (SSL*)thessl;
 836         /* set them both just in case, but usually they are the same BIO */
 837         BIO_set_callback(SSL_get_rbio(ssl), &win_bio_cb);
 838         BIO_set_callback_arg(SSL_get_rbio(ssl), (char*)&c->ev->ev);
 839         BIO_set_callback(SSL_get_wbio(ssl), &win_bio_cb);
 840         BIO_set_callback_arg(SSL_get_wbio(ssl), (char*)&c->ev->ev);
 841 }
 842 #endif
 843
 844 void
 845 comm_point_tcp_accept_callback(int fd, short event, void* arg)
 846 {
 847         struct comm_point* c = (struct comm_point*)arg, *c_hdl;
 848         int new_fd;
 849         log_assert(c->type == comm_tcp_accept);
 850         if(!(event & EV_READ)) {
 851                 log_info("ignoring tcp accept event %d", (int)event);
 852                 return;
 853         }
 854         comm_base_now(c->ev->base);
 855         /* find free tcp handler. */
 856         if(!c->tcp_free) {
 857                 log_warn("accepted too many tcp, connections full");
 858                 return;
 859         }
 860         /* accept incoming connection. */
 861         c_hdl = c->tcp_free;
 862         log_assert(fd != -1);
 863         new_fd = comm_point_perform_accept(c, &c_hdl->repinfo.addr,
 864                 &c_hdl->repinfo.addrlen);
 865         if(new_fd == -1)
 866                 return;
 867         if(c->ssl) {
 868                 c_hdl->ssl = incoming_ssl_fd(c->ssl, new_fd);
 869                 if(!c_hdl->ssl) {
 870                         c_hdl->fd = new_fd;
 871                         comm_point_close(c_hdl);
 872                         return;
 873                 }
 874                 c_hdl->ssl_shake_state = comm_ssl_shake_read;
 875 #ifdef USE_WINSOCK
 876                 comm_point_tcp_win_bio_cb(c_hdl, c_hdl->ssl);
 877 #endif
 878         }
 879
 880         /* grab the tcp handler buffers */
 881         c->tcp_free = c_hdl->tcp_free;
 882         if(!c->tcp_free) {
 883                 /* stop accepting incoming queries for now. */
 884                 comm_point_stop_listening(c);
 885         }
 886         /* addr is dropped. Not needed for tcp reply. */
 887         setup_tcp_handler(c_hdl, new_fd);
 888 }
 889
 890 /** Make tcp handler free for next assignment */
 891 static void
 892 reclaim_tcp_handler(struct comm_point* c)
 893 {
 894         log_assert(c->type == comm_tcp);
 895         if(c->ssl) {
 896 #ifdef HAVE_SSL
 897                 SSL_shutdown(c->ssl);
 898                 SSL_free(c->ssl);
 899                 c->ssl = NULL;
 900 #endif
 901         }
 902         comm_point_close(c);
 903         if(c->tcp_parent) {
 904                 c->tcp_free = c->tcp_parent->tcp_free;
 905                 c->tcp_parent->tcp_free = c;
 906                 if(!c->tcp_free) {
 907                         /* re-enable listening on accept socket */
 908                         comm_point_start_listening(c->tcp_parent, -1, -1);
 909                 }
 910         }
 911 }
 912
 913 /** do the callback when writing is done */
 914 static void
 915 tcp_callback_writer(struct comm_point* c)
 916 {
 917         log_assert(c->type == comm_tcp);
 918         sldns_buffer_clear(c->buffer);
 919         if(c->tcp_do_toggle_rw)
 920                 c->tcp_is_reading = 1;
 921         c->tcp_byte_count = 0;
 922         /* switch from listening(write) to listening(read) */
 923         comm_point_stop_listening(c);
 924         comm_point_start_listening(c, -1, -1);
 925 }
 926
 927 /** do the callback when reading is done */
 928 static void
 929 tcp_callback_reader(struct comm_point* c)
 930 {
 931         log_assert(c->type == comm_tcp || c->type == comm_local);
 932         sldns_buffer_flip(c->buffer);
 933         if(c->tcp_do_toggle_rw)
 934                 c->tcp_is_reading = 0;
 935         c->tcp_byte_count = 0;
 936         if(c->type == comm_tcp)
 937                 comm_point_stop_listening(c);
 938         fptr_ok(fptr_whitelist_comm_point(c->callback));
 939         if( (*c->callback)(c, c->cb_arg, NETEVENT_NOERROR, &c->repinfo) ) {
 940                 comm_point_start_listening(c, -1, TCP_QUERY_TIMEOUT);
 941         }
 942 }
 943
 944 /** continue ssl handshake */
 945 #ifdef HAVE_SSL
 946 static int
 947 ssl_handshake(struct comm_point* c)
 948 {
 949         int r;
 950         if(c->ssl_shake_state == comm_ssl_shake_hs_read) {
 951                 /* read condition satisfied back to writing */
 952                 comm_point_listen_for_rw(c, 1, 1);
 953                 c->ssl_shake_state = comm_ssl_shake_none;
 954                 return 1;
 955         }
 956         if(c->ssl_shake_state == comm_ssl_shake_hs_write) {
 957                 /* write condition satisfied, back to reading */
 958                 comm_point_listen_for_rw(c, 1, 0);
 959                 c->ssl_shake_state = comm_ssl_shake_none;
 960                 return 1;
 961         }
 962
 963         ERR_clear_error();
 964         r = SSL_do_handshake(c->ssl);
 965         if(r != 1) {
 966                 int want = SSL_get_error(c->ssl, r);
 967                 if(want == SSL_ERROR_WANT_READ) {
 968                         if(c->ssl_shake_state == comm_ssl_shake_read)
 969                                 return 1;
 970                         c->ssl_shake_state = comm_ssl_shake_read;
 971                         comm_point_listen_for_rw(c, 1, 0);
 972                         return 1;
 973                 } else if(want == SSL_ERROR_WANT_WRITE) {
 974                         if(c->ssl_shake_state == comm_ssl_shake_write)
 975                                 return 1;
 976                         c->ssl_shake_state = comm_ssl_shake_write;
 977                         comm_point_listen_for_rw(c, 0, 1);
 978                         return 1;
 979                 } else if(r == 0) {
 980                         return 0; /* closed */
 981                 } else if(want == SSL_ERROR_SYSCALL) {
 982                         /* SYSCALL and errno==0 means closed uncleanly */
 983                         if(errno != 0)
 984                                 log_err("SSL_handshake syscall: %s",
 985                                         strerror(errno));
 986                         return 0;
 987                 } else {
 988                         log_crypto_err("ssl handshake failed");
 989                         log_addr(1, "ssl handshake failed", &c->repinfo.addr,
 990                                 c->repinfo.addrlen);
 991                         return 0;
 992                 }
 993         }
 994         /* this is where peer verification could take place */
 995         log_addr(VERB_ALGO, "SSL DNS connection", &c->repinfo.addr,
 996                 c->repinfo.addrlen);
 997
 998         /* setup listen rw correctly */
 999         if(c->tcp_is_reading) {
1000                 if(c->ssl_shake_state != comm_ssl_shake_read)
1001                         comm_point_listen_for_rw(c, 1, 0);
1002         } else {
1003                 comm_point_listen_for_rw(c, 1, 1);
1004         }
1005         c->ssl_shake_state = comm_ssl_shake_none;
1006         return 1;
1007 }
1008 #endif /* HAVE_SSL */
1009
1010 /** ssl read callback on TCP */
1011 static int
1012 ssl_handle_read(struct comm_point* c)
1013 {
1014 #ifdef HAVE_SSL
1015         int r;
1016         if(c->ssl_shake_state != comm_ssl_shake_none) {
1017                 if(!ssl_handshake(c))
1018                         return 0;
1019                 if(c->ssl_shake_state != comm_ssl_shake_none)
1020                         return 1;
1021         }
1022         if(c->tcp_byte_count < sizeof(uint16_t)) {
1023                 /* read length bytes */
1024                 ERR_clear_error();
1025                 if((r=SSL_read(c->ssl, (void*)sldns_buffer_at(c->buffer,
1026                         c->tcp_byte_count), (int)(sizeof(uint16_t) -
1027                         c->tcp_byte_count))) <= 0) {
1028                         int want = SSL_get_error(c->ssl, r);
1029                         if(want == SSL_ERROR_ZERO_RETURN) {
1030                                 return 0; /* shutdown, closed */
1031                         } else if(want == SSL_ERROR_WANT_READ) {
1032                                 return 1; /* read more later */
1033                         } else if(want == SSL_ERROR_WANT_WRITE) {
1034                                 c->ssl_shake_state = comm_ssl_shake_hs_write;
1035                                 comm_point_listen_for_rw(c, 0, 1);
1036                                 return 1;
1037                         } else if(want == SSL_ERROR_SYSCALL) {
1038                                 if(errno != 0)
1039                                         log_err("SSL_read syscall: %s",
1040                                                 strerror(errno));
1041                                 return 0;
1042                         }
1043                         log_crypto_err("could not SSL_read");
1044                         return 0;
1045                 }
1046                 c->tcp_byte_count += r;
1047                 if(c->tcp_byte_count != sizeof(uint16_t))
1048                         return 1;
1049                 if(sldns_buffer_read_u16_at(c->buffer, 0) >
1050                         sldns_buffer_capacity(c->buffer)) {
1051                         verbose(VERB_QUERY, "ssl: dropped larger than buffer");
1052                         return 0;
1053                 }
1054                 sldns_buffer_set_limit(c->buffer,
1055                         sldns_buffer_read_u16_at(c->buffer, 0));
1056                 if(sldns_buffer_limit(c->buffer) < LDNS_HEADER_SIZE) {
1057                         verbose(VERB_QUERY, "ssl: dropped bogus too short.");
1058                         return 0;
1059                 }
1060                 verbose(VERB_ALGO, "Reading ssl tcp query of length %d",
1061                         (int)sldns_buffer_limit(c->buffer));
1062         }
1063         log_assert(sldns_buffer_remaining(c->buffer) > 0);
1064         ERR_clear_error();
1065         r = SSL_read(c->ssl, (void*)sldns_buffer_current(c->buffer),
1066                 (int)sldns_buffer_remaining(c->buffer));
1067         if(r <= 0) {
1068                 int want = SSL_get_error(c->ssl, r);
1069                 if(want == SSL_ERROR_ZERO_RETURN) {
1070                         return 0; /* shutdown, closed */
1071                 } else if(want == SSL_ERROR_WANT_READ) {
1072                         return 1; /* read more later */
1073                 } else if(want == SSL_ERROR_WANT_WRITE) {
1074                         c->ssl_shake_state = comm_ssl_shake_hs_write;
1075                         comm_point_listen_for_rw(c, 0, 1);
1076                         return 1;
1077                 } else if(want == SSL_ERROR_SYSCALL) {
1078                         if(errno != 0)
1079                                 log_err("SSL_read syscall: %s",
1080                                         strerror(errno));
1081                         return 0;
1082                 }
1083                 log_crypto_err("could not SSL_read");
1084                 return 0;
1085         }
1086         sldns_buffer_skip(c->buffer, (ssize_t)r);
1087         if(sldns_buffer_remaining(c->buffer) <= 0) {
1088                 tcp_callback_reader(c);
1089         }
1090         return 1;
1091 #else
1092         (void)c;
1093         return 0;
1094 #endif /* HAVE_SSL */
1095 }
1096
1097 /** ssl write callback on TCP */
1098 static int
1099 ssl_handle_write(struct comm_point* c)
1100 {
1101 #ifdef HAVE_SSL
1102         int r;
1103         if(c->ssl_shake_state != comm_ssl_shake_none) {
1104                 if(!ssl_handshake(c))
1105                         return 0;
1106                 if(c->ssl_shake_state != comm_ssl_shake_none)
1107                         return 1;
1108         }
1109         /* ignore return, if fails we may simply block */
1110         (void)SSL_set_mode(c->ssl, SSL_MODE_ENABLE_PARTIAL_WRITE);
1111         if(c->tcp_byte_count < sizeof(uint16_t)) {
1112                 uint16_t len = htons(sldns_buffer_limit(c->buffer));
1113                 ERR_clear_error();
1114                 r = SSL_write(c->ssl,
1115                         (void*)(((uint8_t*)&len)+c->tcp_byte_count),
1116                         (int)(sizeof(uint16_t)-c->tcp_byte_count));
1117                 if(r <= 0) {
1118                         int want = SSL_get_error(c->ssl, r);
1119                         if(want == SSL_ERROR_ZERO_RETURN) {
1120                                 return 0; /* closed */
1121                         } else if(want == SSL_ERROR_WANT_READ) {
1122                                 c->ssl_shake_state = comm_ssl_shake_read;
1123                                 comm_point_listen_for_rw(c, 1, 0);
1124                                 return 1; /* wait for read condition */
1125                         } else if(want == SSL_ERROR_WANT_WRITE) {
1126                                 return 1; /* write more later */
1127                         } else if(want == SSL_ERROR_SYSCALL) {
1128                                 if(errno != 0)
1129                                         log_err("SSL_write syscall: %s",
1130                                                 strerror(errno));
1131                                 return 0;
1132                         }
1133                         log_crypto_err("could not SSL_write");
1134                         return 0;
1135                 }
1136                 c->tcp_byte_count += r;
1137                 if(c->tcp_byte_count < sizeof(uint16_t))
1138                         return 1;
1139                 sldns_buffer_set_position(c->buffer, c->tcp_byte_count -
1140                         sizeof(uint16_t));
1141                 if(sldns_buffer_remaining(c->buffer) == 0) {
1142                         tcp_callback_writer(c);
1143                         return 1;
1144                 }
1145         }
1146         log_assert(sldns_buffer_remaining(c->buffer) > 0);
1147         ERR_clear_error();
1148         r = SSL_write(c->ssl, (void*)sldns_buffer_current(c->buffer),
1149                 (int)sldns_buffer_remaining(c->buffer));
1150         if(r <= 0) {
1151                 int want = SSL_get_error(c->ssl, r);
1152                 if(want == SSL_ERROR_ZERO_RETURN) {
1153                         return 0; /* closed */
1154                 } else if(want == SSL_ERROR_WANT_READ) {
1155                         c->ssl_shake_state = comm_ssl_shake_read;
1156                         comm_point_listen_for_rw(c, 1, 0);
1157                         return 1; /* wait for read condition */
1158                 } else if(want == SSL_ERROR_WANT_WRITE) {
1159                         return 1; /* write more later */
1160                 } else if(want == SSL_ERROR_SYSCALL) {
1161                         if(errno != 0)
1162                                 log_err("SSL_write syscall: %s",
1163                                         strerror(errno));
1164                         return 0;
1165                 }
1166                 log_crypto_err("could not SSL_write");
1167                 return 0;
1168         }
1169         sldns_buffer_skip(c->buffer, (ssize_t)r);
1170
1171         if(sldns_buffer_remaining(c->buffer) == 0) {
1172                 tcp_callback_writer(c);
1173         }
1174         return 1;
1175 #else
1176         (void)c;
1177         return 0;
1178 #endif /* HAVE_SSL */
1179 }
1180
1181 /** handle ssl tcp connection with dns contents */
1182 static int
1183 ssl_handle_it(struct comm_point* c)
1184 {
1185         if(c->tcp_is_reading)
1186                 return ssl_handle_read(c);
1187         return ssl_handle_write(c);
1188 }
1189
1190 /** Handle tcp reading callback.
1191  * @param fd: file descriptor of socket.
1192  * @param c: comm point to read from into buffer.
1193  * @param short_ok: if true, very short packets are OK (for comm_local).
1194  * @return: 0 on error
1195  */
1196 static int
1197 comm_point_tcp_handle_read(int fd, struct comm_point* c, int short_ok)
1198 {
1199         ssize_t r;
1200         log_assert(c->type == comm_tcp || c->type == comm_local);
1201         if(c->ssl)
1202                 return ssl_handle_it(c);
1203         if(!c->tcp_is_reading)
1204                 return 0;
1205
1206         log_assert(fd != -1);
1207         if(c->tcp_byte_count < sizeof(uint16_t)) {
1208                 /* read length bytes */
1209                 r = recv(fd,(void*)sldns_buffer_at(c->buffer,c->tcp_byte_count),
1210                         sizeof(uint16_t)-c->tcp_byte_count, 0);
1211                 if(r == 0)
1212                         return 0;
1213                 else if(r == -1) {
1214 #ifndef USE_WINSOCK
1215                         if(errno == EINTR || errno == EAGAIN)
1216                                 return 1;
1217 #ifdef ECONNRESET
1218                         if(errno == ECONNRESET && verbosity < 2)
1219                                 return 0; /* silence reset by peer */
1220 #endif
1221                         log_err("read (in tcp s): %s", strerror(errno));
1222 #else /* USE_WINSOCK */
1223                         if(WSAGetLastError() == WSAECONNRESET)
1224                                 return 0;
1225                         if(WSAGetLastError() == WSAEINPROGRESS)
1226                                 return 1;
1227                         if(WSAGetLastError() == WSAEWOULDBLOCK) {
1228                                 winsock_tcp_wouldblock(&c->ev->ev, EV_READ);
1229                                 return 1;
1230                         }
1231                         log_err("read (in tcp s): %s",
1232                                 wsa_strerror(WSAGetLastError()));
1233 #endif
1234                         log_addr(0, "remote address is", &c->repinfo.addr,
1235                                 c->repinfo.addrlen);
1236                         return 0;
1237                 }
1238                 c->tcp_byte_count += r;
1239                 if(c->tcp_byte_count != sizeof(uint16_t))
1240                         return 1;
1241                 if(sldns_buffer_read_u16_at(c->buffer, 0) >
1242                         sldns_buffer_capacity(c->buffer)) {
1243                         verbose(VERB_QUERY, "tcp: dropped larger than buffer");
1244                         return 0;
1245                 }
1246                 sldns_buffer_set_limit(c->buffer,
1247                         sldns_buffer_read_u16_at(c->buffer, 0));
1248                 if(!short_ok &&
1249                         sldns_buffer_limit(c->buffer) < LDNS_HEADER_SIZE) {
1250                         verbose(VERB_QUERY, "tcp: dropped bogus too short.");
1251                         return 0;
1252                 }
1253                 verbose(VERB_ALGO, "Reading tcp query of length %d",
1254                         (int)sldns_buffer_limit(c->buffer));
1255         }
1256
1257         log_assert(sldns_buffer_remaining(c->buffer) > 0);
1258         r = recv(fd, (void*)sldns_buffer_current(c->buffer),
1259                 sldns_buffer_remaining(c->buffer), 0);
1260         if(r == 0) {
1261                 return 0;
1262         } else if(r == -1) {
1263 #ifndef USE_WINSOCK
1264                 if(errno == EINTR || errno == EAGAIN)
1265                         return 1;
1266                 log_err("read (in tcp r): %s", strerror(errno));
1267 #else /* USE_WINSOCK */
1268                 if(WSAGetLastError() == WSAECONNRESET)
1269                         return 0;
1270                 if(WSAGetLastError() == WSAEINPROGRESS)
1271                         return 1;
1272                 if(WSAGetLastError() == WSAEWOULDBLOCK) {
1273                         winsock_tcp_wouldblock(&c->ev->ev, EV_READ);
1274                         return 1;
1275                 }
1276                 log_err("read (in tcp r): %s",
1277                         wsa_strerror(WSAGetLastError()));
1278 #endif
1279                 log_addr(0, "remote address is", &c->repinfo.addr,
1280                         c->repinfo.addrlen);
1281                 return 0;
1282         }
1283         sldns_buffer_skip(c->buffer, r);
1284         if(sldns_buffer_remaining(c->buffer) <= 0) {
1285                 tcp_callback_reader(c);
1286         }
1287         return 1;
1288 }
1289
1290 /**
1291  * Handle tcp writing callback.
1292  * @param fd: file descriptor of socket.
1293  * @param c: comm point to write buffer out of.
1294  * @return: 0 on error
1295  */
1296 static int
1297 comm_point_tcp_handle_write(int fd, struct comm_point* c)
1298 {
1299         ssize_t r;
1300         log_assert(c->type == comm_tcp);
1301         if(c->tcp_is_reading && !c->ssl)
1302                 return 0;
1303         log_assert(fd != -1);
1304         if(c->tcp_byte_count == 0 && c->tcp_check_nb_connect) {
1305                 /* check for pending error from nonblocking connect */
1306                 /* from Stevens, unix network programming, vol1, 3rd ed, p450*/
1307                 int error = 0;
1308                 socklen_t len = (socklen_t)sizeof(error);
1309                 if(getsockopt(fd, SOL_SOCKET, SO_ERROR, (void*)&error,
1310                         &len) < 0){
1311 #ifndef USE_WINSOCK
1312                         error = errno; /* on solaris errno is error */
1313 #else /* USE_WINSOCK */
1314                         error = WSAGetLastError();
1315 #endif
1316                 }
1317 #ifndef USE_WINSOCK
1318 #if defined(EINPROGRESS) && defined(EWOULDBLOCK)
1319                 if(error == EINPROGRESS || error == EWOULDBLOCK)
1320                         return 1; /* try again later */
1321                 else
1322 #endif
1323                 if(error != 0 && verbosity < 2)
1324                         return 0; /* silence lots of chatter in the logs */
1325                 else if(error != 0) {
1326                         log_err("tcp connect: %s", strerror(error));
1327 #else /* USE_WINSOCK */
1328                 /* examine error */
1329                 if(error == WSAEINPROGRESS)
1330                         return 1;
1331                 else if(error == WSAEWOULDBLOCK) {
1332                         winsock_tcp_wouldblock(&c->ev->ev, EV_WRITE);
1333                         return 1;
1334                 } else if(error != 0 && verbosity < 2)
1335                         return 0;
1336                 else if(error != 0) {
1337                         log_err("tcp connect: %s", wsa_strerror(error));
1338 #endif /* USE_WINSOCK */
1339                         log_addr(0, "remote address is", &c->repinfo.addr,
1340                                 c->repinfo.addrlen);
1341                         return 0;
1342                 }
1343         }
1344         if(c->ssl)
1345                 return ssl_handle_it(c);
1346
1347         if(c->tcp_byte_count < sizeof(uint16_t)) {
1348                 uint16_t len = htons(sldns_buffer_limit(c->buffer));
1349 #ifdef HAVE_WRITEV
1350                 struct iovec iov[2];
1351                 iov[0].iov_base = (uint8_t*)&len + c->tcp_byte_count;
1352                 iov[0].iov_len = sizeof(uint16_t) - c->tcp_byte_count;
1353                 iov[1].iov_base = sldns_buffer_begin(c->buffer);
1354                 iov[1].iov_len = sldns_buffer_limit(c->buffer);
1355                 log_assert(iov[0].iov_len > 0);
1356                 log_assert(iov[1].iov_len > 0);
1357                 r = writev(fd, iov, 2);
1358 #else /* HAVE_WRITEV */
1359                 r = send(fd, (void*)(((uint8_t*)&len)+c->tcp_byte_count),
1360                         sizeof(uint16_t)-c->tcp_byte_count, 0);
1361 #endif /* HAVE_WRITEV */
1362                 if(r == -1) {
1363 #ifndef USE_WINSOCK
1364 #ifdef EPIPE
1365                         if(errno == EPIPE && verbosity < 2)
1366                                 return 0; /* silence 'broken pipe' */
1367 #endif
1368                         if(errno == EINTR || errno == EAGAIN)
1369                                 return 1;
1370                         log_err("tcp writev: %s", strerror(errno));
1371 #else
1372                         if(WSAGetLastError() == WSAENOTCONN)
1373                                 return 1;
1374                         if(WSAGetLastError() == WSAEINPROGRESS)
1375                                 return 1;
1376                         if(WSAGetLastError() == WSAEWOULDBLOCK) {
1377                                 winsock_tcp_wouldblock(&c->ev->ev, EV_WRITE);
1378                                 return 1;
1379                         }
1380                         log_err("tcp send s: %s",
1381                                 wsa_strerror(WSAGetLastError()));
1382 #endif
1383                         log_addr(0, "remote address is", &c->repinfo.addr,
1384                                 c->repinfo.addrlen);
1385                         return 0;
1386                 }
1387                 c->tcp_byte_count += r;
1388                 if(c->tcp_byte_count < sizeof(uint16_t))
1389                         return 1;
1390                 sldns_buffer_set_position(c->buffer, c->tcp_byte_count -
1391                         sizeof(uint16_t));
1392                 if(sldns_buffer_remaining(c->buffer) == 0) {
1393                         tcp_callback_writer(c);
1394                         return 1;
1395                 }
1396         }
1397         log_assert(sldns_buffer_remaining(c->buffer) > 0);
1398         r = send(fd, (void*)sldns_buffer_current(c->buffer),
1399                 sldns_buffer_remaining(c->buffer), 0);
1400         if(r == -1) {
1401 #ifndef USE_WINSOCK
1402                 if(errno == EINTR || errno == EAGAIN)
1403                         return 1;
1404                 log_err("tcp send r: %s", strerror(errno));
1405 #else
1406                 if(WSAGetLastError() == WSAEINPROGRESS)
1407                         return 1;
1408                 if(WSAGetLastError() == WSAEWOULDBLOCK) {
1409                         winsock_tcp_wouldblock(&c->ev->ev, EV_WRITE);
1410                         return 1;
1411                 }
1412                 log_err("tcp send r: %s",
1413                         wsa_strerror(WSAGetLastError()));
1414 #endif
1415                 log_addr(0, "remote address is", &c->repinfo.addr,
1416                         c->repinfo.addrlen);
1417                 return 0;
1418         }
1419         sldns_buffer_skip(c->buffer, r);
1420
1421         if(sldns_buffer_remaining(c->buffer) == 0) {
1422                 tcp_callback_writer(c);
1423         }
1424
1425         return 1;
1426 }
1427
1428 void
1429 comm_point_tcp_handle_callback(int fd, short event, void* arg)
1430 {
1431         struct comm_point* c = (struct comm_point*)arg;
1432         log_assert(c->type == comm_tcp);
1433         comm_base_now(c->ev->base);
1434
1435         if(event&EV_READ) {
1436                 if(!comm_point_tcp_handle_read(fd, c, 0)) {
1437                         reclaim_tcp_handler(c);
1438                         if(!c->tcp_do_close) {
1439                                 fptr_ok(fptr_whitelist_comm_point(
1440                                         c->callback));
1441                                 (void)(*c->callback)(c, c->cb_arg,
1442                                         NETEVENT_CLOSED, NULL);
1443                         }
1444                 }
1445                 return;
1446         }
1447         if(event&EV_WRITE) {
1448                 if(!comm_point_tcp_handle_write(fd, c)) {
1449                         reclaim_tcp_handler(c);
1450                         if(!c->tcp_do_close) {
1451                                 fptr_ok(fptr_whitelist_comm_point(
1452                                         c->callback));
1453                                 (void)(*c->callback)(c, c->cb_arg,
1454                                         NETEVENT_CLOSED, NULL);
1455                         }
1456                 }
1457                 return;
1458         }
1459         if(event&EV_TIMEOUT) {
1460                 verbose(VERB_QUERY, "tcp took too long, dropped");
1461                 reclaim_tcp_handler(c);
1462                 if(!c->tcp_do_close) {
1463                         fptr_ok(fptr_whitelist_comm_point(c->callback));
1464                         (void)(*c->callback)(c, c->cb_arg,
1465                                 NETEVENT_TIMEOUT, NULL);
1466                 }
1467                 return;
1468         }
1469         log_err("Ignored event %d for tcphdl.", event);
1470 }
1471
1472 void comm_point_local_handle_callback(int fd, short event, void* arg)
1473 {
1474         struct comm_point* c = (struct comm_point*)arg;
1475         log_assert(c->type == comm_local);
1476         comm_base_now(c->ev->base);
1477
1478         if(event&EV_READ) {
1479                 if(!comm_point_tcp_handle_read(fd, c, 1)) {
1480                         fptr_ok(fptr_whitelist_comm_point(c->callback));
1481                         (void)(*c->callback)(c, c->cb_arg, NETEVENT_CLOSED,
1482                                 NULL);
1483                 }
1484                 return;
1485         }
1486         log_err("Ignored event %d for localhdl.", event);
1487 }
1488
1489 void comm_point_raw_handle_callback(int ATTR_UNUSED(fd),
1490         short event, void* arg)
1491 {
1492         struct comm_point* c = (struct comm_point*)arg;
1493         int err = NETEVENT_NOERROR;
1494         log_assert(c->type == comm_raw);
1495         comm_base_now(c->ev->base);
1496
1497         if(event&EV_TIMEOUT)
1498                 err = NETEVENT_TIMEOUT;
1499         fptr_ok(fptr_whitelist_comm_point_raw(c->callback));
1500         (void)(*c->callback)(c, c->cb_arg, err, NULL);
1501 }
1502
1503 struct comm_point*
1504 comm_point_create_udp(struct comm_base *base, int fd, sldns_buffer* buffer,
1505         comm_point_callback_t* callback, void* callback_arg)
1506 {
1507         struct comm_point* c = (struct comm_point*)calloc(1,
1508                 sizeof(struct comm_point));
1509         short evbits;
1510         if(!c)
1511                 return NULL;
1512         c->ev = (struct internal_event*)calloc(1,
1513                 sizeof(struct internal_event));
1514         if(!c->ev) {
1515                 free(c);
1516                 return NULL;
1517         }
1518         c->ev->base = base;
1519         c->fd = fd;
1520         c->buffer = buffer;
1521         c->timeout = NULL;
1522         c->tcp_is_reading = 0;
1523         c->tcp_byte_count = 0;
1524         c->tcp_parent = NULL;
1525         c->max_tcp_count = 0;
1526         c->tcp_handlers = NULL;
1527         c->tcp_free = NULL;
1528         c->type = comm_udp;
1529         c->tcp_do_close = 0;
1530         c->do_not_close = 0;
1531         c->tcp_do_toggle_rw = 0;
1532         c->tcp_check_nb_connect = 0;
1533         c->inuse = 0;
1534         c->callback = callback;
1535         c->cb_arg = callback_arg;
1536         evbits = EV_READ | EV_PERSIST;
1537         /* libevent stuff */
1538         event_set(&c->ev->ev, c->fd, evbits, comm_point_udp_callback, c);
1539         if(event_base_set(base->eb->base, &c->ev->ev) != 0) {
1540                 log_err("could not baseset udp event");
1541                 comm_point_delete(c);
1542                 return NULL;
1543         }
1544         if(fd!=-1 && event_add(&c->ev->ev, c->timeout) != 0 ) {
1545                 log_err("could not add udp event");
1546                 comm_point_delete(c);
1547                 return NULL;
1548         }
1549         return c;
1550 }
1551
1552 struct comm_point*
1553 comm_point_create_udp_ancil(struct comm_base *base, int fd,
1554         sldns_buffer* buffer,
1555         comm_point_callback_t* callback, void* callback_arg)
1556 {
1557         struct comm_point* c = (struct comm_point*)calloc(1,
1558                 sizeof(struct comm_point));
1559         short evbits;
1560         if(!c)
1561                 return NULL;
1562         c->ev = (struct internal_event*)calloc(1,
1563                 sizeof(struct internal_event));
1564         if(!c->ev) {
1565                 free(c);
1566                 return NULL;
1567         }
1568         c->ev->base = base;
1569         c->fd = fd;
1570         c->buffer = buffer;
1571         c->timeout = NULL;
1572         c->tcp_is_reading = 0;
1573         c->tcp_byte_count = 0;
1574         c->tcp_parent = NULL;
1575         c->max_tcp_count = 0;
1576         c->tcp_handlers = NULL;
1577         c->tcp_free = NULL;
1578         c->type = comm_udp;
1579         c->tcp_do_close = 0;
1580         c->do_not_close = 0;
1581         c->inuse = 0;
1582         c->tcp_do_toggle_rw = 0;
1583         c->tcp_check_nb_connect = 0;
1584         c->callback = callback;
1585         c->cb_arg = callback_arg;
1586         evbits = EV_READ | EV_PERSIST;
1587         /* libevent stuff */
1588         event_set(&c->ev->ev, c->fd, evbits, comm_point_udp_ancil_callback, c);
1589         if(event_base_set(base->eb->base, &c->ev->ev) != 0) {
1590                 log_err("could not baseset udp event");
1591                 comm_point_delete(c);
1592                 return NULL;
1593         }
1594         if(fd!=-1 && event_add(&c->ev->ev, c->timeout) != 0 ) {
1595                 log_err("could not add udp event");
1596                 comm_point_delete(c);
1597                 return NULL;
1598         }
1599         return c;
1600 }
1601
1602 static struct comm_point*
1603 comm_point_create_tcp_handler(struct comm_base *base,
1604         struct comm_point* parent, size_t bufsize,
1605         comm_point_callback_t* callback, void* callback_arg)
1606 {
1607         struct comm_point* c = (struct comm_point*)calloc(1,
1608                 sizeof(struct comm_point));
1609         short evbits;
1610         if(!c)
1611                 return NULL;
1612         c->ev = (struct internal_event*)calloc(1,
1613                 sizeof(struct internal_event));
1614         if(!c->ev) {
1615                 free(c);
1616                 return NULL;
1617         }
1618         c->ev->base = base;
1619         c->fd = -1;
1620         c->buffer = sldns_buffer_new(bufsize);
1621         if(!c->buffer) {
1622                 free(c->ev);
1623                 free(c);
1624                 return NULL;
1625         }
1626         c->timeout = (struct timeval*)malloc(sizeof(struct timeval));
1627         if(!c->timeout) {
1628                 sldns_buffer_free(c->buffer);
1629                 free(c->ev);
1630                 free(c);
1631                 return NULL;
1632         }
1633         c->tcp_is_reading = 0;
1634         c->tcp_byte_count = 0;
1635         c->tcp_parent = parent;
1636         c->max_tcp_count = 0;
1637         c->tcp_handlers = NULL;
1638         c->tcp_free = NULL;
1639         c->type = comm_tcp;
1640         c->tcp_do_close = 0;
1641         c->do_not_close = 0;
1642         c->tcp_do_toggle_rw = 1;
1643         c->tcp_check_nb_connect = 0;
1644         c->repinfo.c = c;
1645         c->callback = callback;
1646         c->cb_arg = callback_arg;
1647         /* add to parent free list */
1648         c->tcp_free = parent->tcp_free;
1649         parent->tcp_free = c;
1650         /* libevent stuff */
1651         evbits = EV_PERSIST | EV_READ | EV_TIMEOUT;
1652         event_set(&c->ev->ev, c->fd, evbits, comm_point_tcp_handle_callback, c);
1653         if(event_base_set(base->eb->base, &c->ev->ev) != 0)
1654         {
1655                 log_err("could not basetset tcphdl event");
1656                 parent->tcp_free = c->tcp_free;
1657                 free(c->ev);
1658                 free(c);
1659                 return NULL;
1660         }
1661         return c;
1662 }
1663
1664 struct comm_point*
1665 comm_point_create_tcp(struct comm_base *base, int fd, int num, size_t bufsize,
1666         comm_point_callback_t* callback, void* callback_arg)
1667 {
1668         struct comm_point* c = (struct comm_point*)calloc(1,
1669                 sizeof(struct comm_point));
1670         short evbits;
1671         int i;
1672         /* first allocate the TCP accept listener */
1673         if(!c)
1674                 return NULL;
1675         c->ev = (struct internal_event*)calloc(1,
1676                 sizeof(struct internal_event));
1677         if(!c->ev) {
1678                 free(c);
1679                 return NULL;
1680         }
1681         c->ev->base = base;
1682         c->fd = fd;
1683         c->buffer = NULL;
1684         c->timeout = NULL;
1685         c->tcp_is_reading = 0;
1686         c->tcp_byte_count = 0;
1687         c->tcp_parent = NULL;
1688         c->max_tcp_count = num;
1689         c->tcp_handlers = (struct comm_point**)calloc((size_t)num,
1690                 sizeof(struct comm_point*));
1691         if(!c->tcp_handlers) {
1692                 free(c->ev);
1693                 free(c);
1694                 return NULL;
1695         }
1696         c->tcp_free = NULL;
1697         c->type = comm_tcp_accept;
1698         c->tcp_do_close = 0;
1699         c->do_not_close = 0;
1700         c->tcp_do_toggle_rw = 0;
1701         c->tcp_check_nb_connect = 0;
1702         c->callback = NULL;
1703         c->cb_arg = NULL;
1704         evbits = EV_READ | EV_PERSIST;
1705         /* libevent stuff */
1706         event_set(&c->ev->ev, c->fd, evbits, comm_point_tcp_accept_callback, c);
1707         if(event_base_set(base->eb->base, &c->ev->ev) != 0 ||
1708                 event_add(&c->ev->ev, c->timeout) != 0 )
1709         {
1710                 log_err("could not add tcpacc event");
1711                 comm_point_delete(c);
1712                 return NULL;
1713         }
1714
1715         /* now prealloc the tcp handlers */
1716         for(i=0; i<num; i++) {
1717                 c->tcp_handlers[i] = comm_point_create_tcp_handler(base,
1718                         c, bufsize, callback, callback_arg);
1719                 if(!c->tcp_handlers[i]) {
1720                         comm_point_delete(c);
1721                         return NULL;
1722                 }
1723         }
1724
1725         return c;
1726 }
1727
1728 struct comm_point*
1729 comm_point_create_tcp_out(struct comm_base *base, size_t bufsize,
1730         comm_point_callback_t* callback, void* callback_arg)
1731 {
1732         struct comm_point* c = (struct comm_point*)calloc(1,
1733                 sizeof(struct comm_point));
1734         short evbits;
1735         if(!c)
1736                 return NULL;
1737         c->ev = (struct internal_event*)calloc(1,
1738                 sizeof(struct internal_event));
1739         if(!c->ev) {
1740                 free(c);
1741                 return NULL;
1742         }
1743         c->ev->base = base;
1744         c->fd = -1;
1745         c->buffer = sldns_buffer_new(bufsize);
1746         if(!c->buffer) {
1747                 free(c->ev);
1748                 free(c);
1749                 return NULL;
1750         }
1751         c->timeout = NULL;
1752         c->tcp_is_reading = 0;
1753         c->tcp_byte_count = 0;
1754         c->tcp_parent = NULL;
1755         c->max_tcp_count = 0;
1756         c->tcp_handlers = NULL;
1757         c->tcp_free = NULL;
1758         c->type = comm_tcp;
1759         c->tcp_do_close = 0;
1760         c->do_not_close = 0;
1761         c->tcp_do_toggle_rw = 1;
1762         c->tcp_check_nb_connect = 1;
1763         c->repinfo.c = c;
1764         c->callback = callback;
1765         c->cb_arg = callback_arg;
1766         evbits = EV_PERSIST | EV_WRITE;
1767         event_set(&c->ev->ev, c->fd, evbits, comm_point_tcp_handle_callback, c);
1768         if(event_base_set(base->eb->base, &c->ev->ev) != 0)
1769         {
1770                 log_err("could not basetset tcpout event");
1771                 sldns_buffer_free(c->buffer);
1772                 free(c->ev);
1773                 free(c);
1774                 return NULL;
1775         }
1776
1777         return c;
1778 }
1779
1780 struct comm_point*
1781 comm_point_create_local(struct comm_base *base, int fd, size_t bufsize,
1782         comm_point_callback_t* callback, void* callback_arg)
1783 {
1784         struct comm_point* c = (struct comm_point*)calloc(1,
1785                 sizeof(struct comm_point));
1786         short evbits;
1787         if(!c)
1788                 return NULL;
1789         c->ev = (struct internal_event*)calloc(1,
1790                 sizeof(struct internal_event));
1791         if(!c->ev) {
1792                 free(c);
1793                 return NULL;
1794         }
1795         c->ev->base = base;
1796         c->fd = fd;
1797         c->buffer = sldns_buffer_new(bufsize);
1798         if(!c->buffer) {
1799                 free(c->ev);
1800                 free(c);
1801                 return NULL;
1802         }
1803         c->timeout = NULL;
1804         c->tcp_is_reading = 1;
1805         c->tcp_byte_count = 0;
1806         c->tcp_parent = NULL;
1807         c->max_tcp_count = 0;
1808         c->tcp_handlers = NULL;
1809         c->tcp_free = NULL;
1810         c->type = comm_local;
1811         c->tcp_do_close = 0;
1812         c->do_not_close = 1;
1813         c->tcp_do_toggle_rw = 0;
1814         c->tcp_check_nb_connect = 0;
1815         c->callback = callback;
1816         c->cb_arg = callback_arg;
1817         /* libevent stuff */
1818         evbits = EV_PERSIST | EV_READ;
1819         event_set(&c->ev->ev, c->fd, evbits, comm_point_local_handle_callback,
1820                 c);
1821         if(event_base_set(base->eb->base, &c->ev->ev) != 0 ||
1822                 event_add(&c->ev->ev, c->timeout) != 0 )
1823         {
1824                 log_err("could not add localhdl event");
1825                 free(c->ev);
1826                 free(c);
1827                 return NULL;
1828         }
1829         return c;
1830 }
1831
1832 struct comm_point*
1833 comm_point_create_raw(struct comm_base* base, int fd, int writing,
1834         comm_point_callback_t* callback, void* callback_arg)
1835 {
1836         struct comm_point* c = (struct comm_point*)calloc(1,
1837                 sizeof(struct comm_point));
1838         short evbits;
1839         if(!c)
1840                 return NULL;
1841         c->ev = (struct internal_event*)calloc(1,
1842                 sizeof(struct internal_event));
1843         if(!c->ev) {
1844                 free(c);
1845                 return NULL;
1846         }
1847         c->ev->base = base;
1848         c->fd = fd;
1849         c->buffer = NULL;
1850         c->timeout = NULL;
1851         c->tcp_is_reading = 0;
1852         c->tcp_byte_count = 0;
1853         c->tcp_parent = NULL;
1854         c->max_tcp_count = 0;
1855         c->tcp_handlers = NULL;
1856         c->tcp_free = NULL;
1857         c->type = comm_raw;
1858         c->tcp_do_close = 0;
1859         c->do_not_close = 1;
1860         c->tcp_do_toggle_rw = 0;
1861         c->tcp_check_nb_connect = 0;
1862         c->callback = callback;
1863         c->cb_arg = callback_arg;
1864         /* libevent stuff */
1865         if(writing)
1866                 evbits = EV_PERSIST | EV_WRITE;
1867         else    evbits = EV_PERSIST | EV_READ;
1868         event_set(&c->ev->ev, c->fd, evbits, comm_point_raw_handle_callback,
1869                 c);
1870         if(event_base_set(base->eb->base, &c->ev->ev) != 0 ||
1871                 event_add(&c->ev->ev, c->timeout) != 0 )
1872         {
1873                 log_err("could not add rawhdl event");
1874                 free(c->ev);
1875                 free(c);
1876                 return NULL;
1877         }
1878         return c;
1879 }
1880
1881 void
1882 comm_point_close(struct comm_point* c)
1883 {
1884         if(!c)
1885                 return;
1886         if(c->fd != -1)
1887                 if(event_del(&c->ev->ev) != 0) {
1888                         log_err("could not event_del on close");
1889                 }
1890         /* close fd after removing from event lists, or epoll.. is messed up */
1891         if(c->fd != -1 && !c->do_not_close) {
1892                 verbose(VERB_ALGO, "close fd %d", c->fd);
1893 #ifndef USE_WINSOCK
1894                 close(c->fd);
1895 #else
1896                 closesocket(c->fd);
1897 #endif
1898         }
1899         c->fd = -1;
1900 }
1901
1902 void
1903 comm_point_delete(struct comm_point* c)
1904 {
1905         if(!c)
1906                 return;
1907         if(c->type == comm_tcp && c->ssl) {
1908 #ifdef HAVE_SSL
1909                 SSL_shutdown(c->ssl);
1910                 SSL_free(c->ssl);
1911 #endif
1912         }
1913         comm_point_close(c);
1914         if(c->tcp_handlers) {
1915                 int i;
1916                 for(i=0; i<c->max_tcp_count; i++)
1917                         comm_point_delete(c->tcp_handlers[i]);
1918                 free(c->tcp_handlers);
1919         }
1920         free(c->timeout);
1921         if(c->type == comm_tcp || c->type == comm_local)
1922                 sldns_buffer_free(c->buffer);
1923         free(c->ev);
1924         free(c);
1925 }
1926
1927 void
1928 comm_point_send_reply(struct comm_reply *repinfo)
1929 {
1930         log_assert(repinfo && repinfo->c);
1931         if(repinfo->c->type == comm_udp) {
1932                 if(repinfo->srctype)
1933                         comm_point_send_udp_msg_if(repinfo->c,
1934                         repinfo->c->buffer, (struct sockaddr*)&repinfo->addr,
1935                         repinfo->addrlen, repinfo);
1936                 else
1937                         comm_point_send_udp_msg(repinfo->c, repinfo->c->buffer,
1938                         (struct sockaddr*)&repinfo->addr, repinfo->addrlen);
1939         } else {
1940                 comm_point_start_listening(repinfo->c, -1, TCP_QUERY_TIMEOUT);
1941         }
1942 }
1943
1944 void
1945 comm_point_drop_reply(struct comm_reply* repinfo)
1946 {
1947         if(!repinfo)
1948                 return;
1949         log_assert(repinfo && repinfo->c);
1950         log_assert(repinfo->c->type != comm_tcp_accept);
1951         if(repinfo->c->type == comm_udp)
1952                 return;
1953         reclaim_tcp_handler(repinfo->c);
1954 }
1955
1956 void
1957 comm_point_stop_listening(struct comm_point* c)
1958 {
1959         verbose(VERB_ALGO, "comm point stop listening %d", c->fd);
1960         if(event_del(&c->ev->ev) != 0) {
1961                 log_err("event_del error to stoplisten");
1962         }
1963 }
1964
1965 void
1966 comm_point_start_listening(struct comm_point* c, int newfd, int sec)
1967 {
1968         verbose(VERB_ALGO, "comm point start listening %d",
1969                 c->fd==-1?newfd:c->fd);
1970         if(c->type == comm_tcp_accept && !c->tcp_free) {
1971                 /* no use to start listening no free slots. */
1972                 return;
1973         }
1974         if(sec != -1 && sec != 0) {
1975                 if(!c->timeout) {
1976                         c->timeout = (struct timeval*)malloc(sizeof(
1977                                 struct timeval));
1978                         if(!c->timeout) {
1979                                 log_err("cpsl: malloc failed. No net read.");
1980                                 return;
1981                         }
1982                 }
1983                 c->ev->ev.ev_events |= EV_TIMEOUT;
1984 #ifndef S_SPLINT_S /* splint fails on struct timeval. */
1985                 c->timeout->tv_sec = sec;
1986                 c->timeout->tv_usec = 0;
1987 #endif /* S_SPLINT_S */
1988         }
1989         if(c->type == comm_tcp) {
1990                 c->ev->ev.ev_events &= ~(EV_READ|EV_WRITE);
1991                 if(c->tcp_is_reading)
1992                         c->ev->ev.ev_events |= EV_READ;
1993                 else    c->ev->ev.ev_events |= EV_WRITE;
1994         }
1995         if(newfd != -1) {
1996                 if(c->fd != -1) {
1997 #ifndef USE_WINSOCK
1998                         close(c->fd);
1999 #else
2000                         closesocket(c->fd);
2001 #endif
2002                 }
2003                 c->fd = newfd;
2004                 c->ev->ev.ev_fd = c->fd;
2005         }
2006         if(event_add(&c->ev->ev, sec==0?NULL:c->timeout) != 0) {
2007                 log_err("event_add failed. in cpsl.");
2008         }
2009 }
2010
2011 void comm_point_listen_for_rw(struct comm_point* c, int rd, int wr)
2012 {
2013         verbose(VERB_ALGO, "comm point listen_for_rw %d %d", c->fd, wr);
2014         if(event_del(&c->ev->ev) != 0) {
2015                 log_err("event_del error to cplf");
2016         }
2017         c->ev->ev.ev_events &= ~(EV_READ|EV_WRITE);
2018         if(rd) c->ev->ev.ev_events |= EV_READ;
2019         if(wr) c->ev->ev.ev_events |= EV_WRITE;
2020         if(event_add(&c->ev->ev, c->timeout) != 0) {
2021                 log_err("event_add failed. in cplf.");
2022         }
2023 }
2024
2025 size_t comm_point_get_mem(struct comm_point* c)
2026 {
2027         size_t s;
2028         if(!c)
2029                 return 0;
2030         s = sizeof(*c) + sizeof(*c->ev);
2031         if(c->timeout)
2032                 s += sizeof(*c->timeout);
2033         if(c->type == comm_tcp || c->type == comm_local)
2034                 s += sizeof(*c->buffer) + sldns_buffer_capacity(c->buffer);
2035         if(c->type == comm_tcp_accept) {
2036                 int i;
2037                 for(i=0; i<c->max_tcp_count; i++)
2038                         s += comm_point_get_mem(c->tcp_handlers[i]);
2039         }
2040         return s;
2041 }
2042
2043 struct comm_timer*
2044 comm_timer_create(struct comm_base* base, void (*cb)(void*), void* cb_arg)
2045 {
2046         struct comm_timer *tm = (struct comm_timer*)calloc(1,
2047                 sizeof(struct comm_timer));
2048         if(!tm)
2049                 return NULL;
2050         tm->ev_timer = (struct internal_timer*)calloc(1,
2051                 sizeof(struct internal_timer));
2052         if(!tm->ev_timer) {
2053                 log_err("malloc failed");
2054                 free(tm);
2055                 return NULL;
2056         }
2057         tm->ev_timer->base = base;
2058         tm->callback = cb;
2059         tm->cb_arg = cb_arg;
2060         event_set(&tm->ev_timer->ev, -1, EV_TIMEOUT,
2061                 comm_timer_callback, tm);
2062         if(event_base_set(base->eb->base, &tm->ev_timer->ev) != 0) {
2063                 log_err("timer_create: event_base_set failed.");
2064                 free(tm->ev_timer);
2065                 free(tm);
2066                 return NULL;
2067         }
2068         return tm;
2069 }
2070
2071 void
2072 comm_timer_disable(struct comm_timer* timer)
2073 {
2074         if(!timer)
2075                 return;
2076         evtimer_del(&timer->ev_timer->ev);
2077         timer->ev_timer->enabled = 0;
2078 }
2079
2080 void
2081 comm_timer_set(struct comm_timer* timer, struct timeval* tv)
2082 {
2083         log_assert(tv);
2084         if(timer->ev_timer->enabled)
2085                 comm_timer_disable(timer);
2086         event_set(&timer->ev_timer->ev, -1, EV_TIMEOUT,
2087                 comm_timer_callback, timer);
2088         if(event_base_set(timer->ev_timer->base->eb->base,
2089                 &timer->ev_timer->ev) != 0)
2090                 log_err("comm_timer_set: set_base failed.");
2091         if(evtimer_add(&timer->ev_timer->ev, tv) != 0)
2092                 log_err("comm_timer_set: evtimer_add failed.");
2093         timer->ev_timer->enabled = 1;
2094 }
2095
2096 void
2097 comm_timer_delete(struct comm_timer* timer)
2098 {
2099         if(!timer)
2100                 return;
2101         comm_timer_disable(timer);
2102         free(timer->ev_timer);
2103         free(timer);
2104 }
2105
2106 void
2107 comm_timer_callback(int ATTR_UNUSED(fd), short event, void* arg)
2108 {
2109         struct comm_timer* tm = (struct comm_timer*)arg;
2110         if(!(event&EV_TIMEOUT))
2111                 return;
2112         comm_base_now(tm->ev_timer->base);
2113         tm->ev_timer->enabled = 0;
2114         fptr_ok(fptr_whitelist_comm_timer(tm->callback));
2115         (*tm->callback)(tm->cb_arg);
2116 }
2117
2118 int
2119 comm_timer_is_set(struct comm_timer* timer)
2120 {
2121         return (int)timer->ev_timer->enabled;
2122 }
2123
2124 size_t
2125 comm_timer_get_mem(struct comm_timer* timer)
2126 {
2127         return sizeof(*timer) + sizeof(struct internal_timer);
2128 }
2129
2130 struct comm_signal*
2131 comm_signal_create(struct comm_base* base,
2132         void (*callback)(int, void*), void* cb_arg)
2133 {
2134         struct comm_signal* com = (struct comm_signal*)malloc(
2135                 sizeof(struct comm_signal));
2136         if(!com) {
2137                 log_err("malloc failed");
2138                 return NULL;
2139         }
2140         com->base = base;
2141         com->callback = callback;
2142         com->cb_arg = cb_arg;
2143         com->ev_signal = NULL;
2144         return com;
2145 }
2146
2147 void
2148 comm_signal_callback(int sig, short event, void* arg)
2149 {
2150         struct comm_signal* comsig = (struct comm_signal*)arg;
2151         if(!(event & EV_SIGNAL))
2152                 return;
2153         comm_base_now(comsig->base);
2154         fptr_ok(fptr_whitelist_comm_signal(comsig->callback));
2155         (*comsig->callback)(sig, comsig->cb_arg);
2156 }
2157
2158 int
2159 comm_signal_bind(struct comm_signal* comsig, int sig)
2160 {
2161         struct internal_signal* entry = (struct internal_signal*)calloc(1,
2162                 sizeof(struct internal_signal));
2163         if(!entry) {
2164                 log_err("malloc failed");
2165                 return 0;
2166         }
2167         log_assert(comsig);
2168         /* add signal event */
2169         signal_set(&entry->ev, sig, comm_signal_callback, comsig);
2170         if(event_base_set(comsig->base->eb->base, &entry->ev) != 0) {
2171                 log_err("Could not set signal base");
2172                 free(entry);
2173                 return 0;
2174         }
2175         if(signal_add(&entry->ev, NULL) != 0) {
2176                 log_err("Could not add signal handler");
2177                 free(entry);
2178                 return 0;
2179         }
2180         /* link into list */
2181         entry->next = comsig->ev_signal;
2182         comsig->ev_signal = entry;
2183         return 1;
2184 }
2185
2186 void
2187 comm_signal_delete(struct comm_signal* comsig)
2188 {
2189         struct internal_signal* p, *np;
2190         if(!comsig)
2191                 return;
2192         p=comsig->ev_signal;
2193         while(p) {
2194                 np = p->next;
2195                 signal_del(&p->ev);
2196                 free(p);
2197                 p = np;
2198         }
2199         free(comsig);
2200 }