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