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