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