1 /* $OpenBSD: frontend.c,v 1.56 2020/11/09 04:22:05 tb Exp $ */ 2 3 /* 4 * Copyright (c) 2018 Florian Obser <florian@openbsd.org> 5 * Copyright (c) 2005 Claudio Jeker <claudio@openbsd.org> 6 * Copyright (c) 2004 Esben Norby <norby@openbsd.org> 7 * Copyright (c) 2003, 2004 Henning Brauer <henning@openbsd.org> 8 * 9 * Permission to use, copy, modify, and distribute this software for any 10 * purpose with or without fee is hereby granted, provided that the above 11 * copyright notice and this permission notice appear in all copies. 12 * 13 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 14 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 15 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 16 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 17 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 18 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 19 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 20 */ 21 22 #include <sys/types.h> 23 #include <sys/queue.h> 24 #include <sys/socket.h> 25 #include <sys/syslog.h> 26 #include <sys/tree.h> 27 #include <sys/uio.h> 28 29 #include <netinet/in.h> 30 #include <net/if.h> 31 #include <net/route.h> 32 33 #include <errno.h> 34 #include <event.h> 35 #include <imsg.h> 36 #include <netdb.h> 37 #include <pwd.h> 38 #include <signal.h> 39 #include <stdint.h> 40 #include <stdio.h> 41 #include <stdlib.h> 42 #include <string.h> 43 #include <time.h> 44 #include <unistd.h> 45 46 #include "libunbound/config.h" 47 #include "libunbound/sldns/pkthdr.h" 48 #include "libunbound/sldns/sbuffer.h" 49 #include "libunbound/sldns/str2wire.h" 50 #include "libunbound/sldns/wire2str.h" 51 #include "libunbound/util/data/dname.h" 52 #include "libunbound/util/data/msgparse.h" 53 #include "libunbound/util/data/msgreply.h" 54 55 #include "log.h" 56 #include "unwind.h" 57 #include "frontend.h" 58 #include "control.h" 59 60 #define ROUTE_SOCKET_BUF_SIZE 16384 61 62 /* 63 * size of a resource record with name a two octed pointer to qname 64 * 2 octets pointer to qname 65 * 2 octets TYPE 66 * 2 octets CLASS 67 * 4 octets TTL 68 * 2 octets RDLENGTH 69 */ 70 #define COMPRESSED_RR_SIZE 12 71 72 struct udp_ev { 73 struct event ev; 74 uint8_t query[65536]; 75 struct msghdr rcvmhdr; 76 struct iovec rcviov[1]; 77 struct sockaddr_storage from; 78 } udp4ev, udp6ev; 79 80 struct pending_query { 81 TAILQ_ENTRY(pending_query) entry; 82 struct sockaddr_storage from; 83 struct sldns_buffer *qbuf; 84 ssize_t len; 85 uint64_t imsg_id; 86 int fd; 87 int bogus; 88 int rcode_override; 89 ssize_t answer_len; 90 uint8_t *answer; 91 }; 92 93 TAILQ_HEAD(, pending_query) pending_queries; 94 95 struct bl_node { 96 RB_ENTRY(bl_node) entry; 97 char *domain; 98 }; 99 100 __dead void frontend_shutdown(void); 101 void frontend_sig_handler(int, short, void *); 102 void frontend_startup(void); 103 void udp_receive(int, short, void *); 104 int check_query(sldns_buffer*); 105 void chaos_answer(struct pending_query *); 106 void send_answer(struct pending_query *); 107 void route_receive(int, short, void *); 108 void handle_route_message(struct rt_msghdr *, 109 struct sockaddr **); 110 void get_rtaddrs(int, struct sockaddr *, 111 struct sockaddr **); 112 void rtmget_default(void); 113 struct pending_query *find_pending_query(uint64_t); 114 void parse_trust_anchor(struct trust_anchor_head *, int); 115 void send_trust_anchors(struct trust_anchor_head *); 116 void write_trust_anchors(struct trust_anchor_head *, int); 117 void parse_blocklist(int); 118 int bl_cmp(struct bl_node *, struct bl_node *); 119 void free_bl(void); 120 int pending_query_cnt(void); 121 122 struct uw_conf *frontend_conf; 123 struct imsgev *iev_main; 124 struct imsgev *iev_resolver; 125 struct event ev_route; 126 int udp4sock = -1, udp6sock = -1, routesock = -1; 127 int ta_fd = -1; 128 129 static struct trust_anchor_head trust_anchors, new_trust_anchors; 130 131 RB_HEAD(bl_tree, bl_node) bl_head = RB_INITIALIZER(&bl_head); 132 RB_PROTOTYPE(bl_tree, bl_node, entry, bl_cmp) 133 RB_GENERATE(bl_tree, bl_node, entry, bl_cmp) 134 135 void 136 frontend_sig_handler(int sig, short event, void *bula) 137 { 138 /* 139 * Normal signal handler rules don't apply because libevent 140 * decouples for us. 141 */ 142 143 switch (sig) { 144 case SIGINT: 145 case SIGTERM: 146 frontend_shutdown(); 147 default: 148 fatalx("unexpected signal"); 149 } 150 } 151 152 void 153 frontend(int debug, int verbose) 154 { 155 struct event ev_sigint, ev_sigterm; 156 struct passwd *pw; 157 158 frontend_conf = config_new_empty(); 159 control_state.fd = -1; 160 161 log_init(debug, LOG_DAEMON); 162 log_setverbose(verbose); 163 164 if ((pw = getpwnam(UNWIND_USER)) == NULL) 165 fatal("getpwnam"); 166 167 if (chroot(pw->pw_dir) == -1) 168 fatal("chroot"); 169 if (chdir("/") == -1) 170 fatal("chdir(\"/\")"); 171 172 uw_process = PROC_FRONTEND; 173 setproctitle("%s", log_procnames[uw_process]); 174 log_procinit(log_procnames[uw_process]); 175 176 if (setgroups(1, &pw->pw_gid) || 177 setresgid(pw->pw_gid, pw->pw_gid, pw->pw_gid) || 178 setresuid(pw->pw_uid, pw->pw_uid, pw->pw_uid)) 179 fatal("can't drop privileges"); 180 181 if (pledge("stdio unix recvfd", NULL) == -1) 182 fatal("pledge"); 183 184 event_init(); 185 186 /* Setup signal handler. */ 187 signal_set(&ev_sigint, SIGINT, frontend_sig_handler, NULL); 188 signal_set(&ev_sigterm, SIGTERM, frontend_sig_handler, NULL); 189 signal_add(&ev_sigint, NULL); 190 signal_add(&ev_sigterm, NULL); 191 signal(SIGPIPE, SIG_IGN); 192 signal(SIGHUP, SIG_IGN); 193 194 /* Setup pipe and event handler to the parent process. */ 195 if (iev_main != NULL) 196 fatal("iev_main"); 197 if ((iev_main = malloc(sizeof(struct imsgev))) == NULL) 198 fatal(NULL); 199 imsg_init(&iev_main->ibuf, 3); 200 iev_main->handler = frontend_dispatch_main; 201 iev_main->events = EV_READ; 202 event_set(&iev_main->ev, iev_main->ibuf.fd, iev_main->events, 203 iev_main->handler, iev_main); 204 event_add(&iev_main->ev, NULL); 205 206 udp4ev.rcviov[0].iov_base = (caddr_t)udp4ev.query; 207 udp4ev.rcviov[0].iov_len = sizeof(udp4ev.query); 208 udp4ev.rcvmhdr.msg_name = (caddr_t)&udp4ev.from; 209 udp4ev.rcvmhdr.msg_namelen = sizeof(udp4ev.from); 210 udp4ev.rcvmhdr.msg_iov = udp4ev.rcviov; 211 udp4ev.rcvmhdr.msg_iovlen = 1; 212 213 udp6ev.rcviov[0].iov_base = (caddr_t)udp6ev.query; 214 udp6ev.rcviov[0].iov_len = sizeof(udp6ev.query); 215 udp6ev.rcvmhdr.msg_name = (caddr_t)&udp6ev.from; 216 udp6ev.rcvmhdr.msg_namelen = sizeof(udp6ev.from); 217 udp6ev.rcvmhdr.msg_iov = udp6ev.rcviov; 218 udp6ev.rcvmhdr.msg_iovlen = 1; 219 220 TAILQ_INIT(&pending_queries); 221 222 TAILQ_INIT(&trust_anchors); 223 TAILQ_INIT(&new_trust_anchors); 224 225 add_new_ta(&trust_anchors, KSK2017); 226 227 event_dispatch(); 228 229 frontend_shutdown(); 230 } 231 232 __dead void 233 frontend_shutdown(void) 234 { 235 /* Close pipes. */ 236 msgbuf_write(&iev_resolver->ibuf.w); 237 msgbuf_clear(&iev_resolver->ibuf.w); 238 close(iev_resolver->ibuf.fd); 239 msgbuf_write(&iev_main->ibuf.w); 240 msgbuf_clear(&iev_main->ibuf.w); 241 close(iev_main->ibuf.fd); 242 243 config_clear(frontend_conf); 244 245 free(iev_resolver); 246 free(iev_main); 247 248 log_info("frontend exiting"); 249 exit(0); 250 } 251 252 int 253 frontend_imsg_compose_main(int type, pid_t pid, void *data, uint16_t datalen) 254 { 255 return (imsg_compose_event(iev_main, type, 0, pid, -1, data, datalen)); 256 } 257 258 int 259 frontend_imsg_compose_resolver(int type, pid_t pid, void *data, 260 uint16_t datalen) 261 { 262 return (imsg_compose_event(iev_resolver, type, 0, pid, -1, data, 263 datalen)); 264 } 265 266 void 267 frontend_dispatch_main(int fd, short event, void *bula) 268 { 269 static struct uw_conf *nconf; 270 struct imsg imsg; 271 struct imsgev *iev = bula; 272 struct imsgbuf *ibuf = &iev->ibuf; 273 int n, shut = 0; 274 275 if (event & EV_READ) { 276 if ((n = imsg_read(ibuf)) == -1 && errno != EAGAIN) 277 fatal("imsg_read error"); 278 if (n == 0) /* Connection closed. */ 279 shut = 1; 280 } 281 if (event & EV_WRITE) { 282 if ((n = msgbuf_write(&ibuf->w)) == -1 && errno != EAGAIN) 283 fatal("msgbuf_write"); 284 if (n == 0) /* Connection closed. */ 285 shut = 1; 286 } 287 288 for (;;) { 289 if ((n = imsg_get(ibuf, &imsg)) == -1) 290 fatal("%s: imsg_get error", __func__); 291 if (n == 0) /* No more messages. */ 292 break; 293 294 switch (imsg.hdr.type) { 295 case IMSG_SOCKET_IPC_RESOLVER: 296 /* 297 * Setup pipe and event handler to the resolver 298 * process. 299 */ 300 if (iev_resolver) { 301 fatalx("%s: received unexpected imsg fd " 302 "to frontend", __func__); 303 break; 304 } 305 if ((fd = imsg.fd) == -1) { 306 fatalx("%s: expected to receive imsg fd to " 307 "frontend but didn't receive any", 308 __func__); 309 break; 310 } 311 312 if (iev_resolver != NULL) 313 fatal("iev_resolver"); 314 iev_resolver = malloc(sizeof(struct imsgev)); 315 if (iev_resolver == NULL) 316 fatal(NULL); 317 318 imsg_init(&iev_resolver->ibuf, fd); 319 iev_resolver->handler = frontend_dispatch_resolver; 320 iev_resolver->events = EV_READ; 321 322 event_set(&iev_resolver->ev, iev_resolver->ibuf.fd, 323 iev_resolver->events, iev_resolver->handler, 324 iev_resolver); 325 event_add(&iev_resolver->ev, NULL); 326 break; 327 case IMSG_RECONF_CONF: 328 case IMSG_RECONF_BLOCKLIST_FILE: 329 case IMSG_RECONF_FORWARDER: 330 case IMSG_RECONF_DOT_FORWARDER: 331 case IMSG_RECONF_FORCE: 332 imsg_receive_config(&imsg, &nconf); 333 break; 334 case IMSG_RECONF_END: 335 if (nconf == NULL) 336 fatalx("%s: IMSG_RECONF_END without " 337 "IMSG_RECONF_CONF", __func__); 338 merge_config(frontend_conf, nconf); 339 if (frontend_conf->blocklist_file == NULL) 340 free_bl(); 341 nconf = NULL; 342 break; 343 case IMSG_UDP6SOCK: 344 if (udp6sock != -1) 345 fatalx("%s: received unexpected udp6sock", 346 __func__); 347 if ((udp6sock = imsg.fd) == -1) 348 fatalx("%s: expected to receive imsg " 349 "UDP6 fd but didn't receive any", __func__); 350 event_set(&udp6ev.ev, udp6sock, EV_READ | EV_PERSIST, 351 udp_receive, &udp6ev); 352 event_add(&udp6ev.ev, NULL); 353 break; 354 case IMSG_UDP4SOCK: 355 if (udp4sock != -1) 356 fatalx("%s: received unexpected udp4sock", 357 __func__); 358 if ((udp4sock = imsg.fd) == -1) 359 fatalx("%s: expected to receive imsg " 360 "UDP4 fd but didn't receive any", __func__); 361 event_set(&udp4ev.ev, udp4sock, EV_READ | EV_PERSIST, 362 udp_receive, &udp4ev); 363 event_add(&udp4ev.ev, NULL); 364 break; 365 case IMSG_ROUTESOCK: 366 if (routesock != -1) 367 fatalx("%s: received unexpected routesock", 368 __func__); 369 if ((fd = imsg.fd) == -1) 370 fatalx("%s: expected to receive imsg " 371 "routesocket fd but didn't receive any", 372 __func__); 373 routesock = fd; 374 event_set(&ev_route, fd, EV_READ | EV_PERSIST, 375 route_receive, NULL); 376 break; 377 case IMSG_STARTUP: 378 frontend_startup(); 379 break; 380 case IMSG_CONTROLFD: 381 if (control_state.fd != -1) 382 fatalx("%s: received unexpected controlsock", 383 __func__); 384 if ((fd = imsg.fd) == -1) 385 fatalx("%s: expected to receive imsg control " 386 "fd but didn't receive any", __func__); 387 control_state.fd = fd; 388 /* Listen on control socket. */ 389 TAILQ_INIT(&ctl_conns); 390 control_listen(); 391 break; 392 case IMSG_TAFD: 393 if ((ta_fd = imsg.fd) != -1) 394 parse_trust_anchor(&trust_anchors, ta_fd); 395 if (!TAILQ_EMPTY(&trust_anchors)) 396 send_trust_anchors(&trust_anchors); 397 break; 398 case IMSG_BLFD: 399 if ((fd = imsg.fd) == -1) 400 fatalx("%s: expected to receive imsg block " 401 "list fd but didn't receive any", __func__); 402 parse_blocklist(fd); 403 break; 404 default: 405 log_debug("%s: error handling imsg %d", __func__, 406 imsg.hdr.type); 407 break; 408 } 409 imsg_free(&imsg); 410 } 411 if (!shut) 412 imsg_event_add(iev); 413 else { 414 /* This pipe is dead. Remove its event handler. */ 415 event_del(&iev->ev); 416 event_loopexit(NULL); 417 } 418 } 419 420 void 421 frontend_dispatch_resolver(int fd, short event, void *bula) 422 { 423 struct pending_query *pq; 424 struct imsgev *iev = bula; 425 struct imsgbuf *ibuf = &iev->ibuf; 426 struct imsg imsg; 427 struct query_imsg *query_imsg; 428 struct answer_imsg *answer_imsg; 429 int n, shut = 0, chg; 430 uint8_t *p; 431 432 if (event & EV_READ) { 433 if ((n = imsg_read(ibuf)) == -1 && errno != EAGAIN) 434 fatal("imsg_read error"); 435 if (n == 0) /* Connection closed. */ 436 shut = 1; 437 } 438 if (event & EV_WRITE) { 439 if ((n = msgbuf_write(&ibuf->w)) == -1 && errno != EAGAIN) 440 fatal("msgbuf_write"); 441 if (n == 0) /* Connection closed. */ 442 shut = 1; 443 } 444 445 for (;;) { 446 if ((n = imsg_get(ibuf, &imsg)) == -1) 447 fatal("%s: imsg_get error", __func__); 448 if (n == 0) /* No more messages. */ 449 break; 450 451 switch (imsg.hdr.type) { 452 case IMSG_ANSWER_HEADER: 453 if (IMSG_DATA_SIZE(imsg) != sizeof(*query_imsg)) 454 fatalx("%s: IMSG_ANSWER_HEADER wrong length: " 455 "%lu", __func__, IMSG_DATA_SIZE(imsg)); 456 query_imsg = (struct query_imsg *)imsg.data; 457 if ((pq = find_pending_query(query_imsg->id)) == 458 NULL) { 459 log_warnx("cannot find pending query %llu", 460 query_imsg->id); 461 break; 462 } 463 if (query_imsg->err) { 464 send_answer(pq); 465 pq = NULL; 466 break; 467 } 468 pq->bogus = query_imsg->bogus; 469 break; 470 case IMSG_ANSWER: 471 if (IMSG_DATA_SIZE(imsg) != sizeof(*answer_imsg)) 472 fatalx("%s: IMSG_ANSWER wrong length: " 473 "%lu", __func__, IMSG_DATA_SIZE(imsg)); 474 answer_imsg = (struct answer_imsg *)imsg.data; 475 if ((pq = find_pending_query(answer_imsg->id)) == 476 NULL) { 477 log_warnx("cannot find pending query %llu", 478 answer_imsg->id); 479 break; 480 } 481 482 p = realloc(pq->answer, pq->answer_len + 483 answer_imsg->len); 484 485 if (p != NULL) { 486 pq->answer = p; 487 memcpy(pq->answer + pq->answer_len, 488 answer_imsg->answer, answer_imsg->len); 489 pq->answer_len += answer_imsg->len; 490 } else { 491 free(pq->answer); 492 pq->answer_len = 0; 493 pq->answer = NULL; 494 pq->rcode_override = LDNS_RCODE_SERVFAIL; 495 send_answer(pq); 496 break; 497 } 498 if (!answer_imsg->truncated) 499 send_answer(pq); 500 break; 501 case IMSG_CTL_RESOLVER_INFO: 502 case IMSG_CTL_AUTOCONF_RESOLVER_INFO: 503 case IMSG_CTL_MEM_INFO: 504 case IMSG_CTL_END: 505 control_imsg_relay(&imsg); 506 break; 507 case IMSG_NEW_TA: 508 /* make sure this is a string */ 509 ((char *)imsg.data)[IMSG_DATA_SIZE(imsg) - 1] = '\0'; 510 add_new_ta(&new_trust_anchors, imsg.data); 511 break; 512 case IMSG_NEW_TAS_ABORT: 513 free_tas(&new_trust_anchors); 514 break; 515 case IMSG_NEW_TAS_DONE: 516 chg = merge_tas(&new_trust_anchors, &trust_anchors); 517 if (chg) 518 send_trust_anchors(&trust_anchors); 519 520 /* 521 * always write trust anchors, the modify date on 522 * the file is an indication when we made progress 523 */ 524 if (ta_fd != -1) 525 write_trust_anchors(&trust_anchors, ta_fd); 526 break; 527 default: 528 log_debug("%s: error handling imsg %d", __func__, 529 imsg.hdr.type); 530 break; 531 } 532 imsg_free(&imsg); 533 } 534 if (!shut) 535 imsg_event_add(iev); 536 else { 537 /* This pipe is dead. Remove its event handler. */ 538 event_del(&iev->ev); 539 event_loopexit(NULL); 540 } 541 } 542 543 void 544 frontend_startup(void) 545 { 546 if (!event_initialized(&ev_route)) 547 fatalx("%s: did not receive a route socket from the main " 548 "process", __func__); 549 550 event_add(&ev_route, NULL); 551 552 frontend_imsg_compose_main(IMSG_STARTUP_DONE, 0, NULL, 0); 553 } 554 555 void 556 udp_receive(int fd, short events, void *arg) 557 { 558 struct udp_ev *udpev = (struct udp_ev *)arg; 559 struct pending_query *pq; 560 struct query_imsg query_imsg; 561 struct query_info qinfo; 562 struct bl_node find; 563 ssize_t len, dname_len; 564 int ret; 565 char *str; 566 char dname[LDNS_MAX_DOMAINLEN + 1]; 567 char qclass_buf[16]; 568 char qtype_buf[16]; 569 570 memset(&qinfo, 0, sizeof(qinfo)); 571 572 if ((len = recvmsg(fd, &udpev->rcvmhdr, 0)) == -1) { 573 log_warn("recvmsg"); 574 return; 575 } 576 577 if ((pq = calloc(1, sizeof(*pq))) == NULL) { 578 log_warn(NULL); 579 return; 580 } 581 582 pq->rcode_override = LDNS_RCODE_NOERROR; 583 pq->len = len; 584 pq->from = udpev->from; 585 pq->fd = fd; 586 587 do { 588 arc4random_buf(&pq->imsg_id, sizeof(pq->imsg_id)); 589 } while(find_pending_query(pq->imsg_id) != NULL); 590 591 if ((pq->qbuf = sldns_buffer_new(len)) == NULL) { 592 log_warnx("sldns_buffer_new"); 593 goto drop; 594 } 595 sldns_buffer_clear(pq->qbuf); 596 sldns_buffer_write(pq->qbuf, udpev->query, len); 597 sldns_buffer_flip(pq->qbuf); 598 599 if (log_getverbose() & OPT_VERBOSE2 && (str = 600 sldns_wire2str_pkt(udpev->query, len)) != NULL) { 601 log_debug("from: %s\n%s", ip_port((struct sockaddr *) 602 &udpev->from), str); 603 free(str); 604 } 605 606 if ((ret = check_query(pq->qbuf)) != LDNS_RCODE_NOERROR) { 607 if (ret == -1) 608 goto drop; 609 else 610 pq->rcode_override = ret; 611 goto send_answer; 612 } 613 614 if (!query_info_parse(&qinfo, pq->qbuf)) { 615 pq->rcode_override = LDNS_RCODE_FORMERR; 616 goto send_answer; 617 } 618 619 if ((dname_len = dname_valid(qinfo.qname, qinfo.qname_len)) == 0) { 620 pq->rcode_override = LDNS_RCODE_FORMERR; 621 goto send_answer; 622 } 623 dname_str(qinfo.qname, dname); 624 625 sldns_wire2str_class_buf(qinfo.qclass, qclass_buf, sizeof(qclass_buf)); 626 sldns_wire2str_type_buf(qinfo.qtype, qtype_buf, sizeof(qtype_buf)); 627 log_debug("%s: %s %s %s ?", ip_port((struct sockaddr *)&udpev->from), 628 dname, qclass_buf, qtype_buf); 629 630 find.domain = dname; 631 if (RB_FIND(bl_tree, &bl_head, &find) != NULL) { 632 if (frontend_conf->blocklist_log) 633 log_info("blocking %s", dname); 634 pq->rcode_override = LDNS_RCODE_REFUSED; 635 goto send_answer; 636 } 637 638 if (qinfo.qtype == LDNS_RR_TYPE_AXFR || qinfo.qtype == 639 LDNS_RR_TYPE_IXFR) { 640 pq->rcode_override = LDNS_RCODE_REFUSED; 641 goto send_answer; 642 } 643 644 if(qinfo.qtype == LDNS_RR_TYPE_OPT || 645 qinfo.qtype == LDNS_RR_TYPE_TSIG || 646 qinfo.qtype == LDNS_RR_TYPE_TKEY || 647 qinfo.qtype == LDNS_RR_TYPE_MAILA || 648 qinfo.qtype == LDNS_RR_TYPE_MAILB || 649 (qinfo.qtype >= 128 && qinfo.qtype <= 248)) { 650 pq->rcode_override = LDNS_RCODE_FORMERR; 651 goto send_answer; 652 } 653 654 if (qinfo.qclass == LDNS_RR_CLASS_CH) { 655 if (strcasecmp(dname, "version.server.") == 0 || 656 strcasecmp(dname, "version.bind.") == 0) { 657 chaos_answer(pq); 658 } else 659 pq->rcode_override = LDNS_RCODE_REFUSED; 660 goto send_answer; 661 } 662 663 if (strlcpy(query_imsg.qname, dname, sizeof(query_imsg.qname)) >= 664 sizeof(query_imsg.qname)) { 665 log_warnx("qname too long"); 666 pq->rcode_override = LDNS_RCODE_FORMERR; 667 goto send_answer; 668 } 669 query_imsg.id = pq->imsg_id; 670 query_imsg.t = qinfo.qtype; 671 query_imsg.c = qinfo.qclass; 672 673 if (frontend_imsg_compose_resolver(IMSG_QUERY, 0, &query_imsg, 674 sizeof(query_imsg)) != -1) 675 TAILQ_INSERT_TAIL(&pending_queries, pq, entry); 676 else { 677 pq->rcode_override = LDNS_RCODE_SERVFAIL; 678 goto send_answer; 679 } 680 return; 681 682 send_answer: 683 TAILQ_INSERT_TAIL(&pending_queries, pq, entry); 684 send_answer(pq); 685 pq = NULL; 686 drop: 687 if (pq != NULL) 688 sldns_buffer_free(pq->qbuf); 689 free(pq); 690 } 691 692 void 693 chaos_answer(struct pending_query *pq) 694 { 695 struct sldns_buffer buf, *pkt = &buf; 696 size_t size, len; 697 char *name = "unwind"; 698 699 len = strlen(name); 700 size = sldns_buffer_capacity(pq->qbuf) + COMPRESSED_RR_SIZE + 1 + len; 701 702 if (pq->answer != 0) 703 fatal("chaos_answer"); 704 if ((pq->answer = calloc(1, size)) == NULL) 705 return; 706 pq->answer_len = size; 707 memcpy(pq->answer, sldns_buffer_begin(pq->qbuf), 708 sldns_buffer_capacity(pq->qbuf)); 709 sldns_buffer_init_frm_data(pkt, pq->answer, size); 710 711 sldns_buffer_clear(pkt); 712 713 sldns_buffer_skip(pkt, sizeof(uint16_t)); /* skip id */ 714 sldns_buffer_write_u16(pkt, 0); /* clear flags */ 715 LDNS_QR_SET(sldns_buffer_begin(pkt)); 716 LDNS_RA_SET(sldns_buffer_begin(pkt)); 717 if (LDNS_RD_WIRE(sldns_buffer_begin(pq->qbuf))) 718 LDNS_RD_SET(sldns_buffer_begin(pkt)); 719 if (LDNS_CD_WIRE(sldns_buffer_begin(pq->qbuf))) 720 LDNS_CD_SET(sldns_buffer_begin(pkt)); 721 LDNS_RCODE_SET(sldns_buffer_begin(pkt), LDNS_RCODE_NOERROR); 722 sldns_buffer_write_u16(pkt, 1); /* qdcount */ 723 sldns_buffer_write_u16(pkt, 1); /* ancount */ 724 sldns_buffer_write_u16(pkt, 0); /* nscount */ 725 sldns_buffer_write_u16(pkt, 0); /* arcount */ 726 (void)query_dname_len(pkt); /* skip qname */ 727 sldns_buffer_skip(pkt, sizeof(uint16_t)); /* skip qtype */ 728 sldns_buffer_skip(pkt, sizeof(uint16_t)); /* skip qclass */ 729 730 sldns_buffer_write_u16(pkt, 0xc00c); /* ptr to query */ 731 sldns_buffer_write_u16(pkt, LDNS_RR_TYPE_TXT); 732 sldns_buffer_write_u16(pkt, LDNS_RR_CLASS_CH); 733 sldns_buffer_write_u32(pkt, 0); /* TTL */ 734 sldns_buffer_write_u16(pkt, 1 + len); /* RDLENGTH */ 735 sldns_buffer_write_u8(pkt, len); /* length octed */ 736 sldns_buffer_write(pkt, name, len); 737 } 738 739 int 740 check_query(sldns_buffer* pkt) 741 { 742 if(sldns_buffer_limit(pkt) < LDNS_HEADER_SIZE) { 743 log_warnx("bad query: too short, dropped"); 744 return -1; 745 } 746 if(LDNS_QR_WIRE(sldns_buffer_begin(pkt))) { 747 log_warnx("bad query: QR set, dropped"); 748 return -1; 749 } 750 if(LDNS_TC_WIRE(sldns_buffer_begin(pkt))) { 751 LDNS_TC_CLR(sldns_buffer_begin(pkt)); 752 log_warnx("bad query: TC set"); 753 return (LDNS_RCODE_FORMERR); 754 } 755 if(!(LDNS_RD_WIRE(sldns_buffer_begin(pkt)))) { 756 log_warnx("bad query: RD not set"); 757 return (LDNS_RCODE_REFUSED); 758 } 759 if(LDNS_OPCODE_WIRE(sldns_buffer_begin(pkt)) != LDNS_PACKET_QUERY) { 760 log_warnx("bad query: unknown opcode %d", 761 LDNS_OPCODE_WIRE(sldns_buffer_begin(pkt))); 762 return (LDNS_RCODE_NOTIMPL); 763 } 764 765 if (LDNS_QDCOUNT(sldns_buffer_begin(pkt)) != 1 && 766 LDNS_ANCOUNT(sldns_buffer_begin(pkt))!= 0 && 767 LDNS_NSCOUNT(sldns_buffer_begin(pkt))!= 0 && 768 LDNS_ARCOUNT(sldns_buffer_begin(pkt)) > 1) { 769 log_warnx("bad query: qdcount: %d, ancount: %d " 770 "nscount: %d, arcount: %d", 771 LDNS_QDCOUNT(sldns_buffer_begin(pkt)), 772 LDNS_ANCOUNT(sldns_buffer_begin(pkt)), 773 LDNS_NSCOUNT(sldns_buffer_begin(pkt)), 774 LDNS_ARCOUNT(sldns_buffer_begin(pkt))); 775 return (LDNS_RCODE_FORMERR); 776 } 777 return 0; 778 } 779 780 void 781 send_answer(struct pending_query *pq) 782 { 783 ssize_t len; 784 char *str; 785 uint8_t *answer; 786 787 answer = pq->answer; 788 len = pq->answer_len; 789 790 if (answer == NULL) { 791 answer = sldns_buffer_begin(pq->qbuf); 792 len = pq->len; 793 794 LDNS_QR_SET(answer); 795 LDNS_RA_SET(answer); 796 if (pq->rcode_override != LDNS_RCODE_NOERROR) 797 LDNS_RCODE_SET(answer, pq->rcode_override); 798 else 799 LDNS_RCODE_SET(answer, LDNS_RCODE_SERVFAIL); 800 } else { 801 if (pq->bogus) { 802 if(LDNS_CD_WIRE(sldns_buffer_begin(pq->qbuf))) { 803 LDNS_ID_SET(answer, LDNS_ID_WIRE( 804 sldns_buffer_begin(pq->qbuf))); 805 LDNS_CD_SET(answer); 806 } else { 807 answer = sldns_buffer_begin(pq->qbuf); 808 len = pq->len; 809 810 LDNS_QR_SET(answer); 811 LDNS_RA_SET(answer); 812 LDNS_RCODE_SET(answer, LDNS_RCODE_SERVFAIL); 813 } 814 } else { 815 LDNS_ID_SET(answer, LDNS_ID_WIRE(sldns_buffer_begin( 816 pq->qbuf))); 817 } 818 } 819 820 if (log_getverbose() & OPT_VERBOSE2 && (str = 821 sldns_wire2str_pkt(answer, len)) != NULL) { 822 log_debug("to: %s\n%s", 823 ip_port((struct sockaddr *)&pq->from),str); 824 free(str); 825 log_debug("pending query count: %d", pending_query_cnt()); 826 } 827 828 if(sendto(pq->fd, answer, len, 0, (struct sockaddr *)&pq->from, 829 pq->from.ss_len) == -1) 830 log_warn("sendto"); 831 832 TAILQ_REMOVE(&pending_queries, pq, entry); 833 sldns_buffer_free(pq->qbuf); 834 free(pq->answer); 835 free(pq); 836 } 837 838 char* 839 ip_port(struct sockaddr *sa) 840 { 841 static char hbuf[NI_MAXHOST], buf[NI_MAXHOST]; 842 843 if (getnameinfo(sa, sa->sa_len, hbuf, sizeof(hbuf), NULL, 0, 844 NI_NUMERICHOST) != 0) { 845 snprintf(buf, sizeof(buf), "%s", "(unknown)"); 846 return buf; 847 } 848 849 if (sa->sa_family == AF_INET6) 850 snprintf(buf, sizeof(buf), "[%s]:%d", hbuf, ntohs( 851 ((struct sockaddr_in6 *)sa)->sin6_port)); 852 if (sa->sa_family == AF_INET) 853 snprintf(buf, sizeof(buf), "[%s]:%d", hbuf, ntohs( 854 ((struct sockaddr_in *)sa)->sin_port)); 855 856 return buf; 857 } 858 859 struct pending_query* 860 find_pending_query(uint64_t id) 861 { 862 struct pending_query *pq; 863 864 TAILQ_FOREACH(pq, &pending_queries, entry) 865 if (pq->imsg_id == id) 866 return pq; 867 return NULL; 868 } 869 870 void 871 route_receive(int fd, short events, void *arg) 872 { 873 static uint8_t *buf; 874 875 struct rt_msghdr *rtm; 876 struct sockaddr *sa, *rti_info[RTAX_MAX]; 877 ssize_t n; 878 879 if (buf == NULL) { 880 buf = malloc(ROUTE_SOCKET_BUF_SIZE); 881 if (buf == NULL) 882 fatal("malloc"); 883 } 884 rtm = (struct rt_msghdr *)buf; 885 if ((n = read(fd, buf, ROUTE_SOCKET_BUF_SIZE)) == -1) { 886 if (errno == EAGAIN || errno == EINTR) 887 return; 888 log_warn("dispatch_rtmsg: read error"); 889 return; 890 } 891 892 if (n == 0) 893 fatal("routing socket closed"); 894 895 if (n < (ssize_t)sizeof(rtm->rtm_msglen) || n < rtm->rtm_msglen) { 896 log_warnx("partial rtm of %zd in buffer", n); 897 return; 898 } 899 900 if (rtm->rtm_version != RTM_VERSION) 901 return; 902 903 sa = (struct sockaddr *)(buf + rtm->rtm_hdrlen); 904 get_rtaddrs(rtm->rtm_addrs, sa, rti_info); 905 906 handle_route_message(rtm, rti_info); 907 } 908 909 #define ROUNDUP(a) \ 910 ((a) > 0 ? (1 + (((a) - 1) | (sizeof(long) - 1))) : sizeof(long)) 911 912 void 913 get_rtaddrs(int addrs, struct sockaddr *sa, struct sockaddr **rti_info) 914 { 915 int i; 916 917 for (i = 0; i < RTAX_MAX; i++) { 918 if (addrs & (1 << i)) { 919 rti_info[i] = sa; 920 sa = (struct sockaddr *)((char *)(sa) + 921 ROUNDUP(sa->sa_len)); 922 } else 923 rti_info[i] = NULL; 924 } 925 } 926 927 void 928 handle_route_message(struct rt_msghdr *rtm, struct sockaddr **rti_info) 929 { 930 struct imsg_rdns_proposal rdns_proposal; 931 struct sockaddr_rtdns *rtdns; 932 struct if_announcemsghdr *ifan; 933 934 switch (rtm->rtm_type) { 935 case RTM_IFANNOUNCE: 936 ifan = (struct if_announcemsghdr *)rtm; 937 if (ifan->ifan_what == IFAN_ARRIVAL) 938 break; 939 rdns_proposal.if_index = ifan->ifan_index; 940 rdns_proposal.src = 0; 941 rdns_proposal.rtdns.sr_family = AF_INET; 942 rdns_proposal.rtdns.sr_len = offsetof(struct sockaddr_rtdns, 943 sr_dns); 944 frontend_imsg_compose_resolver(IMSG_REPLACE_DNS, 0, 945 &rdns_proposal, sizeof(rdns_proposal)); 946 break; 947 case RTM_IFINFO: 948 frontend_imsg_compose_resolver(IMSG_NETWORK_CHANGED, 0, NULL, 949 0); 950 break; 951 case RTM_PROPOSAL: 952 if (!(rtm->rtm_addrs & RTA_DNS)) 953 break; 954 955 rtdns = (struct sockaddr_rtdns*)rti_info[RTAX_DNS]; 956 switch (rtdns->sr_family) { 957 case AF_INET: 958 if ((rtdns->sr_len - 2) % sizeof(struct in_addr) != 0) { 959 log_warnx("ignoring invalid RTM_PROPOSAL"); 960 return; 961 } 962 break; 963 case AF_INET6: 964 if ((rtdns->sr_len - 2) % sizeof(struct in6_addr) != 0) { 965 log_warnx("ignoring invalid RTM_PROPOSAL"); 966 return; 967 } 968 break; 969 default: 970 log_warnx("ignoring invalid RTM_PROPOSAL"); 971 return; 972 } 973 rdns_proposal.if_index = rtm->rtm_index; 974 rdns_proposal.src = rtm->rtm_priority; 975 memcpy(&rdns_proposal.rtdns, rtdns, sizeof(rdns_proposal.rtdns)); 976 frontend_imsg_compose_resolver(IMSG_REPLACE_DNS, 0, 977 &rdns_proposal, sizeof(rdns_proposal)); 978 break; 979 default: 980 break; 981 } 982 } 983 984 void 985 add_new_ta(struct trust_anchor_head *tah, char *val) 986 { 987 struct trust_anchor *ta, *i; 988 int cmp; 989 990 if ((ta = malloc(sizeof(*ta))) == NULL) 991 fatal("%s", __func__); 992 if ((ta->ta = strdup(val)) == NULL) 993 fatal("%s", __func__); 994 995 /* keep the list sorted to prevent churn if the order changes in DNS */ 996 TAILQ_FOREACH(i, tah, entry) { 997 cmp = strcmp(i->ta, ta->ta); 998 if ( cmp == 0) { 999 /* duplicate */ 1000 free(ta->ta); 1001 free(ta); 1002 return; 1003 } else if (cmp > 0) { 1004 TAILQ_INSERT_BEFORE(i, ta, entry); 1005 return; 1006 } 1007 } 1008 TAILQ_INSERT_TAIL(tah, ta, entry); 1009 } 1010 1011 void 1012 free_tas(struct trust_anchor_head *tah) 1013 { 1014 struct trust_anchor *ta; 1015 1016 while ((ta = TAILQ_FIRST(tah))) { 1017 TAILQ_REMOVE(tah, ta, entry); 1018 free(ta->ta); 1019 free(ta); 1020 } 1021 } 1022 1023 int 1024 merge_tas(struct trust_anchor_head *newh, struct trust_anchor_head *oldh) 1025 { 1026 struct trust_anchor *i, *j; 1027 int chg = 0; 1028 1029 j = TAILQ_FIRST(oldh); 1030 1031 TAILQ_FOREACH(i, newh, entry) { 1032 if (j == NULL || strcmp(i->ta, j->ta) != 0) { 1033 chg = 1; 1034 break; 1035 } 1036 j = TAILQ_NEXT(j, entry); 1037 } 1038 if (j != NULL) 1039 chg = 1; 1040 1041 if (chg) { 1042 free_tas(oldh); 1043 TAILQ_CONCAT(oldh, newh, entry); 1044 } else { 1045 free_tas(newh); 1046 } 1047 return (chg); 1048 } 1049 1050 void 1051 parse_trust_anchor(struct trust_anchor_head *tah, int fd) 1052 { 1053 size_t len, dname_len; 1054 ssize_t n, sz; 1055 uint8_t rr[LDNS_RR_BUF_SIZE]; 1056 char *str, *p, buf[512], *line; 1057 1058 sz = 0; 1059 str = NULL; 1060 1061 while ((n = read(fd, buf, sizeof(buf))) > 0) { 1062 p = recallocarray(str, sz, sz + n, 1); 1063 if (p == NULL) { 1064 log_warn("%s", __func__); 1065 goto out; 1066 } 1067 str = p; 1068 memcpy(str + sz, buf, n); 1069 sz += n; 1070 } 1071 1072 if (n == -1) { 1073 log_warn("%s", __func__); 1074 goto out; 1075 } 1076 1077 /* make it a string */ 1078 p = recallocarray(str, sz, sz + 1, 1); 1079 if (p == NULL) { 1080 log_warn("%s", __func__); 1081 goto out; 1082 } 1083 str = p; 1084 sz++; 1085 1086 len = sizeof(rr); 1087 1088 while ((line = strsep(&p, "\n")) != NULL) { 1089 if (sldns_str2wire_rr_buf(line, rr, &len, &dname_len, 1090 ROOT_DNSKEY_TTL, NULL, 0, NULL, 0) != 0) 1091 continue; 1092 if (sldns_wirerr_get_type(rr, len, dname_len) == 1093 LDNS_RR_TYPE_DNSKEY) 1094 add_new_ta(tah, line); 1095 } 1096 1097 out: 1098 free(str); 1099 return; 1100 } 1101 1102 void 1103 send_trust_anchors(struct trust_anchor_head *tah) 1104 { 1105 struct trust_anchor *ta; 1106 1107 TAILQ_FOREACH(ta, tah, entry) 1108 frontend_imsg_compose_resolver(IMSG_NEW_TA, 0, ta->ta, 1109 strlen(ta->ta) + 1); 1110 frontend_imsg_compose_resolver(IMSG_NEW_TAS_DONE, 0, NULL, 0); 1111 } 1112 1113 void 1114 write_trust_anchors(struct trust_anchor_head *tah, int fd) 1115 { 1116 struct trust_anchor *ta; 1117 size_t len = 0; 1118 ssize_t n; 1119 char *str; 1120 1121 if (lseek(fd, 0, SEEK_SET) == -1) { 1122 log_warn("%s", __func__); 1123 goto out; 1124 } 1125 1126 TAILQ_FOREACH(ta, tah, entry) { 1127 if ((n = asprintf(&str, "%s\n", ta->ta)) == -1) { 1128 log_warn("%s", __func__); 1129 len = 0; 1130 goto out; 1131 } 1132 len += n; 1133 if (write(fd, str, n) != n) { 1134 log_warn("%s", __func__); 1135 free(str); 1136 len = 0; 1137 goto out; 1138 } 1139 free(str); 1140 } 1141 out: 1142 ftruncate(fd, len); 1143 fsync(fd); 1144 } 1145 1146 void 1147 parse_blocklist(int fd) 1148 { 1149 FILE *f; 1150 struct bl_node *bl_node; 1151 char *line = NULL; 1152 size_t linesize = 0; 1153 ssize_t linelen; 1154 1155 if((f = fdopen(fd, "r")) == NULL) { 1156 log_warn("cannot read block list"); 1157 close(fd); 1158 return; 1159 } 1160 1161 free_bl(); 1162 1163 while ((linelen = getline(&line, &linesize, f)) != -1) { 1164 if (line[linelen - 1] == '\n') { 1165 if (linelen >= 2 && line[linelen - 2] != '.') 1166 line[linelen - 1] = '.'; 1167 else 1168 line[linelen - 1] = '\0'; 1169 } 1170 1171 bl_node = malloc(sizeof *bl_node); 1172 if (bl_node == NULL) 1173 fatal("%s: malloc", __func__); 1174 if ((bl_node->domain = strdup(line)) == NULL) 1175 fatal("%s: strdup", __func__); 1176 if (RB_INSERT(bl_tree, &bl_head, bl_node) != NULL) { 1177 log_warnx("duplicate blocked domain \"%s\"", line); 1178 free(bl_node->domain); 1179 free(bl_node); 1180 } 1181 } 1182 free(line); 1183 if (ferror(f)) 1184 log_warn("getline"); 1185 fclose(f); 1186 } 1187 1188 int 1189 bl_cmp(struct bl_node *e1, struct bl_node *e2) { 1190 return (strcasecmp(e1->domain, e2->domain)); 1191 } 1192 1193 void 1194 free_bl(void) 1195 { 1196 struct bl_node *n, *nxt; 1197 1198 RB_FOREACH_SAFE(n, bl_tree, &bl_head, nxt) { 1199 RB_REMOVE(bl_tree, &bl_head, n); 1200 free(n->domain); 1201 free(n); 1202 } 1203 } 1204 1205 int 1206 pending_query_cnt(void) 1207 { 1208 struct pending_query *e; 1209 int cnt = 0; 1210 1211 TAILQ_FOREACH(e, &pending_queries, entry) 1212 cnt++; 1213 return cnt; 1214 } 1215