1 /* $NetBSD: peer.c,v 1.9 2022/09/23 12:15:30 christos Exp $ */ 2 3 /* 4 * Copyright (C) Internet Systems Consortium, Inc. ("ISC") 5 * 6 * SPDX-License-Identifier: MPL-2.0 7 * 8 * This Source Code Form is subject to the terms of the Mozilla Public 9 * License, v. 2.0. If a copy of the MPL was not distributed with this 10 * file, you can obtain one at https://mozilla.org/MPL/2.0/. 11 * 12 * See the COPYRIGHT file distributed with this work for additional 13 * information regarding copyright ownership. 14 */ 15 16 /*! \file */ 17 18 #include <inttypes.h> 19 #include <stdbool.h> 20 21 #include <isc/mem.h> 22 #include <isc/sockaddr.h> 23 #include <isc/string.h> 24 #include <isc/util.h> 25 26 #include <dns/bit.h> 27 #include <dns/fixedname.h> 28 #include <dns/name.h> 29 #include <dns/peer.h> 30 31 /*% 32 * Bit positions in the dns_peer_t structure flags field 33 */ 34 #define BOGUS_BIT 0 35 #define SERVER_TRANSFER_FORMAT_BIT 1 36 #define TRANSFERS_BIT 2 37 #define PROVIDE_IXFR_BIT 3 38 #define REQUEST_IXFR_BIT 4 39 #define SUPPORT_EDNS_BIT 5 40 #define SERVER_UDPSIZE_BIT 6 41 #define SERVER_MAXUDP_BIT 7 42 #define REQUEST_NSID_BIT 8 43 #define SEND_COOKIE_BIT 9 44 #define NOTIFY_DSCP_BIT 10 45 #define TRANSFER_DSCP_BIT 11 46 #define QUERY_DSCP_BIT 12 47 #define REQUEST_EXPIRE_BIT 13 48 #define EDNS_VERSION_BIT 14 49 #define FORCE_TCP_BIT 15 50 #define SERVER_PADDING_BIT 16 51 #define REQUEST_TCP_KEEPALIVE_BIT 17 52 53 static void 54 peerlist_delete(dns_peerlist_t **list); 55 56 static void 57 peer_delete(dns_peer_t **peer); 58 59 isc_result_t 60 dns_peerlist_new(isc_mem_t *mem, dns_peerlist_t **list) { 61 dns_peerlist_t *l; 62 63 REQUIRE(list != NULL); 64 65 l = isc_mem_get(mem, sizeof(*l)); 66 67 ISC_LIST_INIT(l->elements); 68 l->mem = mem; 69 isc_refcount_init(&l->refs, 1); 70 l->magic = DNS_PEERLIST_MAGIC; 71 72 *list = l; 73 74 return (ISC_R_SUCCESS); 75 } 76 77 void 78 dns_peerlist_attach(dns_peerlist_t *source, dns_peerlist_t **target) { 79 REQUIRE(DNS_PEERLIST_VALID(source)); 80 REQUIRE(target != NULL); 81 REQUIRE(*target == NULL); 82 83 isc_refcount_increment(&source->refs); 84 85 *target = source; 86 } 87 88 void 89 dns_peerlist_detach(dns_peerlist_t **list) { 90 dns_peerlist_t *plist; 91 92 REQUIRE(list != NULL); 93 REQUIRE(*list != NULL); 94 REQUIRE(DNS_PEERLIST_VALID(*list)); 95 96 plist = *list; 97 *list = NULL; 98 99 if (isc_refcount_decrement(&plist->refs) == 1) { 100 peerlist_delete(&plist); 101 } 102 } 103 104 static void 105 peerlist_delete(dns_peerlist_t **list) { 106 dns_peerlist_t *l; 107 dns_peer_t *server, *stmp; 108 109 REQUIRE(list != NULL); 110 REQUIRE(DNS_PEERLIST_VALID(*list)); 111 112 l = *list; 113 *list = NULL; 114 115 isc_refcount_destroy(&l->refs); 116 117 server = ISC_LIST_HEAD(l->elements); 118 while (server != NULL) { 119 stmp = ISC_LIST_NEXT(server, next); 120 ISC_LIST_UNLINK(l->elements, server, next); 121 dns_peer_detach(&server); 122 server = stmp; 123 } 124 125 l->magic = 0; 126 isc_mem_put(l->mem, l, sizeof(*l)); 127 } 128 129 void 130 dns_peerlist_addpeer(dns_peerlist_t *peers, dns_peer_t *peer) { 131 dns_peer_t *p = NULL; 132 133 dns_peer_attach(peer, &p); 134 135 /* 136 * More specifics to front of list. 137 */ 138 for (p = ISC_LIST_HEAD(peers->elements); p != NULL; 139 p = ISC_LIST_NEXT(p, next)) { 140 if (p->prefixlen < peer->prefixlen) { 141 break; 142 } 143 } 144 145 if (p != NULL) { 146 ISC_LIST_INSERTBEFORE(peers->elements, p, peer, next); 147 } else { 148 ISC_LIST_APPEND(peers->elements, peer, next); 149 } 150 } 151 152 isc_result_t 153 dns_peerlist_peerbyaddr(dns_peerlist_t *servers, const isc_netaddr_t *addr, 154 dns_peer_t **retval) { 155 dns_peer_t *server; 156 isc_result_t res; 157 158 REQUIRE(retval != NULL); 159 REQUIRE(DNS_PEERLIST_VALID(servers)); 160 161 server = ISC_LIST_HEAD(servers->elements); 162 while (server != NULL) { 163 if (isc_netaddr_eqprefix(addr, &server->address, 164 server->prefixlen)) { 165 break; 166 } 167 168 server = ISC_LIST_NEXT(server, next); 169 } 170 171 if (server != NULL) { 172 *retval = server; 173 res = ISC_R_SUCCESS; 174 } else { 175 res = ISC_R_NOTFOUND; 176 } 177 178 return (res); 179 } 180 181 isc_result_t 182 dns_peerlist_currpeer(dns_peerlist_t *peers, dns_peer_t **retval) { 183 dns_peer_t *p = NULL; 184 185 p = ISC_LIST_TAIL(peers->elements); 186 187 dns_peer_attach(p, retval); 188 189 return (ISC_R_SUCCESS); 190 } 191 192 isc_result_t 193 dns_peer_new(isc_mem_t *mem, const isc_netaddr_t *addr, dns_peer_t **peerptr) { 194 unsigned int prefixlen = 0; 195 196 REQUIRE(peerptr != NULL); 197 switch (addr->family) { 198 case AF_INET: 199 prefixlen = 32; 200 break; 201 case AF_INET6: 202 prefixlen = 128; 203 break; 204 default: 205 UNREACHABLE(); 206 } 207 208 return (dns_peer_newprefix(mem, addr, prefixlen, peerptr)); 209 } 210 211 isc_result_t 212 dns_peer_newprefix(isc_mem_t *mem, const isc_netaddr_t *addr, 213 unsigned int prefixlen, dns_peer_t **peerptr) { 214 dns_peer_t *peer; 215 216 REQUIRE(peerptr != NULL && *peerptr == NULL); 217 218 peer = isc_mem_get(mem, sizeof(*peer)); 219 220 *peer = (dns_peer_t){ 221 .magic = DNS_PEER_MAGIC, 222 .address = *addr, 223 .prefixlen = prefixlen, 224 .mem = mem, 225 .transfer_format = dns_one_answer, 226 }; 227 228 isc_refcount_init(&peer->refs, 1); 229 230 ISC_LINK_INIT(peer, next); 231 232 *peerptr = peer; 233 234 return (ISC_R_SUCCESS); 235 } 236 237 void 238 dns_peer_attach(dns_peer_t *source, dns_peer_t **target) { 239 REQUIRE(DNS_PEER_VALID(source)); 240 REQUIRE(target != NULL); 241 REQUIRE(*target == NULL); 242 243 isc_refcount_increment(&source->refs); 244 245 *target = source; 246 } 247 248 void 249 dns_peer_detach(dns_peer_t **peer) { 250 dns_peer_t *p; 251 252 REQUIRE(peer != NULL); 253 REQUIRE(*peer != NULL); 254 REQUIRE(DNS_PEER_VALID(*peer)); 255 256 p = *peer; 257 *peer = NULL; 258 259 if (isc_refcount_decrement(&p->refs) == 1) { 260 peer_delete(&p); 261 } 262 } 263 264 static void 265 peer_delete(dns_peer_t **peer) { 266 dns_peer_t *p; 267 isc_mem_t *mem; 268 269 REQUIRE(peer != NULL); 270 REQUIRE(DNS_PEER_VALID(*peer)); 271 272 p = *peer; 273 *peer = NULL; 274 275 isc_refcount_destroy(&p->refs); 276 277 mem = p->mem; 278 p->mem = NULL; 279 p->magic = 0; 280 281 if (p->key != NULL) { 282 dns_name_free(p->key, mem); 283 isc_mem_put(mem, p->key, sizeof(dns_name_t)); 284 } 285 286 if (p->query_source != NULL) { 287 isc_mem_put(mem, p->query_source, sizeof(*p->query_source)); 288 } 289 290 if (p->notify_source != NULL) { 291 isc_mem_put(mem, p->notify_source, sizeof(*p->notify_source)); 292 } 293 294 if (p->transfer_source != NULL) { 295 isc_mem_put(mem, p->transfer_source, 296 sizeof(*p->transfer_source)); 297 } 298 299 isc_mem_put(mem, p, sizeof(*p)); 300 } 301 302 isc_result_t 303 dns_peer_setbogus(dns_peer_t *peer, bool newval) { 304 bool existed; 305 306 REQUIRE(DNS_PEER_VALID(peer)); 307 308 existed = DNS_BIT_CHECK(BOGUS_BIT, &peer->bitflags); 309 310 peer->bogus = newval; 311 DNS_BIT_SET(BOGUS_BIT, &peer->bitflags); 312 313 return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS); 314 } 315 316 isc_result_t 317 dns_peer_getbogus(dns_peer_t *peer, bool *retval) { 318 REQUIRE(DNS_PEER_VALID(peer)); 319 REQUIRE(retval != NULL); 320 321 if (DNS_BIT_CHECK(BOGUS_BIT, &peer->bitflags)) { 322 *retval = peer->bogus; 323 return (ISC_R_SUCCESS); 324 } else { 325 return (ISC_R_NOTFOUND); 326 } 327 } 328 329 isc_result_t 330 dns_peer_setprovideixfr(dns_peer_t *peer, bool newval) { 331 bool existed; 332 333 REQUIRE(DNS_PEER_VALID(peer)); 334 335 existed = DNS_BIT_CHECK(PROVIDE_IXFR_BIT, &peer->bitflags); 336 337 peer->provide_ixfr = newval; 338 DNS_BIT_SET(PROVIDE_IXFR_BIT, &peer->bitflags); 339 340 return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS); 341 } 342 343 isc_result_t 344 dns_peer_getprovideixfr(dns_peer_t *peer, bool *retval) { 345 REQUIRE(DNS_PEER_VALID(peer)); 346 REQUIRE(retval != NULL); 347 348 if (DNS_BIT_CHECK(PROVIDE_IXFR_BIT, &peer->bitflags)) { 349 *retval = peer->provide_ixfr; 350 return (ISC_R_SUCCESS); 351 } else { 352 return (ISC_R_NOTFOUND); 353 } 354 } 355 356 isc_result_t 357 dns_peer_setrequestixfr(dns_peer_t *peer, bool newval) { 358 bool existed; 359 360 REQUIRE(DNS_PEER_VALID(peer)); 361 362 existed = DNS_BIT_CHECK(REQUEST_IXFR_BIT, &peer->bitflags); 363 364 peer->request_ixfr = newval; 365 DNS_BIT_SET(REQUEST_IXFR_BIT, &peer->bitflags); 366 367 return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS); 368 } 369 370 isc_result_t 371 dns_peer_getrequestixfr(dns_peer_t *peer, bool *retval) { 372 REQUIRE(DNS_PEER_VALID(peer)); 373 REQUIRE(retval != NULL); 374 375 if (DNS_BIT_CHECK(REQUEST_IXFR_BIT, &peer->bitflags)) { 376 *retval = peer->request_ixfr; 377 return (ISC_R_SUCCESS); 378 } else { 379 return (ISC_R_NOTFOUND); 380 } 381 } 382 383 isc_result_t 384 dns_peer_setsupportedns(dns_peer_t *peer, bool newval) { 385 bool existed; 386 387 REQUIRE(DNS_PEER_VALID(peer)); 388 389 existed = DNS_BIT_CHECK(SUPPORT_EDNS_BIT, &peer->bitflags); 390 391 peer->support_edns = newval; 392 DNS_BIT_SET(SUPPORT_EDNS_BIT, &peer->bitflags); 393 394 return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS); 395 } 396 397 isc_result_t 398 dns_peer_getsupportedns(dns_peer_t *peer, bool *retval) { 399 REQUIRE(DNS_PEER_VALID(peer)); 400 REQUIRE(retval != NULL); 401 402 if (DNS_BIT_CHECK(SUPPORT_EDNS_BIT, &peer->bitflags)) { 403 *retval = peer->support_edns; 404 return (ISC_R_SUCCESS); 405 } else { 406 return (ISC_R_NOTFOUND); 407 } 408 } 409 410 isc_result_t 411 dns_peer_setrequestnsid(dns_peer_t *peer, bool newval) { 412 bool existed; 413 414 REQUIRE(DNS_PEER_VALID(peer)); 415 416 existed = DNS_BIT_CHECK(REQUEST_NSID_BIT, &peer->bitflags); 417 418 peer->request_nsid = newval; 419 DNS_BIT_SET(REQUEST_NSID_BIT, &peer->bitflags); 420 421 return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS); 422 } 423 424 isc_result_t 425 dns_peer_getrequestnsid(dns_peer_t *peer, bool *retval) { 426 REQUIRE(DNS_PEER_VALID(peer)); 427 REQUIRE(retval != NULL); 428 429 if (DNS_BIT_CHECK(REQUEST_NSID_BIT, &peer->bitflags)) { 430 *retval = peer->request_nsid; 431 return (ISC_R_SUCCESS); 432 } else { 433 return (ISC_R_NOTFOUND); 434 } 435 } 436 437 isc_result_t 438 dns_peer_setsendcookie(dns_peer_t *peer, bool newval) { 439 bool existed; 440 441 REQUIRE(DNS_PEER_VALID(peer)); 442 443 existed = DNS_BIT_CHECK(SEND_COOKIE_BIT, &peer->bitflags); 444 445 peer->send_cookie = newval; 446 DNS_BIT_SET(SEND_COOKIE_BIT, &peer->bitflags); 447 448 return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS); 449 } 450 451 isc_result_t 452 dns_peer_getsendcookie(dns_peer_t *peer, bool *retval) { 453 REQUIRE(DNS_PEER_VALID(peer)); 454 REQUIRE(retval != NULL); 455 456 if (DNS_BIT_CHECK(SEND_COOKIE_BIT, &peer->bitflags)) { 457 *retval = peer->send_cookie; 458 return (ISC_R_SUCCESS); 459 } else { 460 return (ISC_R_NOTFOUND); 461 } 462 } 463 464 isc_result_t 465 dns_peer_setrequestexpire(dns_peer_t *peer, bool newval) { 466 bool existed; 467 468 REQUIRE(DNS_PEER_VALID(peer)); 469 470 existed = DNS_BIT_CHECK(REQUEST_EXPIRE_BIT, &peer->bitflags); 471 472 peer->request_expire = newval; 473 DNS_BIT_SET(REQUEST_EXPIRE_BIT, &peer->bitflags); 474 475 return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS); 476 } 477 478 isc_result_t 479 dns_peer_getrequestexpire(dns_peer_t *peer, bool *retval) { 480 REQUIRE(DNS_PEER_VALID(peer)); 481 REQUIRE(retval != NULL); 482 483 if (DNS_BIT_CHECK(REQUEST_EXPIRE_BIT, &peer->bitflags)) { 484 *retval = peer->request_expire; 485 return (ISC_R_SUCCESS); 486 } else { 487 return (ISC_R_NOTFOUND); 488 } 489 } 490 491 isc_result_t 492 dns_peer_setforcetcp(dns_peer_t *peer, bool newval) { 493 bool existed; 494 495 REQUIRE(DNS_PEER_VALID(peer)); 496 497 existed = DNS_BIT_CHECK(FORCE_TCP_BIT, &peer->bitflags); 498 499 peer->force_tcp = newval; 500 DNS_BIT_SET(FORCE_TCP_BIT, &peer->bitflags); 501 502 return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS); 503 } 504 505 isc_result_t 506 dns_peer_getforcetcp(dns_peer_t *peer, bool *retval) { 507 REQUIRE(DNS_PEER_VALID(peer)); 508 REQUIRE(retval != NULL); 509 510 if (DNS_BIT_CHECK(FORCE_TCP_BIT, &peer->bitflags)) { 511 *retval = peer->force_tcp; 512 return (ISC_R_SUCCESS); 513 } else { 514 return (ISC_R_NOTFOUND); 515 } 516 } 517 518 isc_result_t 519 dns_peer_settcpkeepalive(dns_peer_t *peer, bool newval) { 520 bool existed; 521 522 REQUIRE(DNS_PEER_VALID(peer)); 523 524 existed = DNS_BIT_CHECK(REQUEST_TCP_KEEPALIVE_BIT, &peer->bitflags); 525 526 peer->tcp_keepalive = newval; 527 DNS_BIT_SET(REQUEST_TCP_KEEPALIVE_BIT, &peer->bitflags); 528 529 return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS); 530 } 531 532 isc_result_t 533 dns_peer_gettcpkeepalive(dns_peer_t *peer, bool *retval) { 534 REQUIRE(DNS_PEER_VALID(peer)); 535 REQUIRE(retval != NULL); 536 537 if (DNS_BIT_CHECK(REQUEST_TCP_KEEPALIVE_BIT, &peer->bitflags)) { 538 *retval = peer->tcp_keepalive; 539 return (ISC_R_SUCCESS); 540 } else { 541 return (ISC_R_NOTFOUND); 542 } 543 } 544 545 isc_result_t 546 dns_peer_settransfers(dns_peer_t *peer, uint32_t newval) { 547 bool existed; 548 549 REQUIRE(DNS_PEER_VALID(peer)); 550 551 existed = DNS_BIT_CHECK(TRANSFERS_BIT, &peer->bitflags); 552 553 peer->transfers = newval; 554 DNS_BIT_SET(TRANSFERS_BIT, &peer->bitflags); 555 556 return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS); 557 } 558 559 isc_result_t 560 dns_peer_gettransfers(dns_peer_t *peer, uint32_t *retval) { 561 REQUIRE(DNS_PEER_VALID(peer)); 562 REQUIRE(retval != NULL); 563 564 if (DNS_BIT_CHECK(TRANSFERS_BIT, &peer->bitflags)) { 565 *retval = peer->transfers; 566 return (ISC_R_SUCCESS); 567 } else { 568 return (ISC_R_NOTFOUND); 569 } 570 } 571 572 isc_result_t 573 dns_peer_settransferformat(dns_peer_t *peer, dns_transfer_format_t newval) { 574 bool existed; 575 576 REQUIRE(DNS_PEER_VALID(peer)); 577 578 existed = DNS_BIT_CHECK(SERVER_TRANSFER_FORMAT_BIT, &peer->bitflags); 579 580 peer->transfer_format = newval; 581 DNS_BIT_SET(SERVER_TRANSFER_FORMAT_BIT, &peer->bitflags); 582 583 return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS); 584 } 585 586 isc_result_t 587 dns_peer_gettransferformat(dns_peer_t *peer, dns_transfer_format_t *retval) { 588 REQUIRE(DNS_PEER_VALID(peer)); 589 REQUIRE(retval != NULL); 590 591 if (DNS_BIT_CHECK(SERVER_TRANSFER_FORMAT_BIT, &peer->bitflags)) { 592 *retval = peer->transfer_format; 593 return (ISC_R_SUCCESS); 594 } else { 595 return (ISC_R_NOTFOUND); 596 } 597 } 598 599 isc_result_t 600 dns_peer_getkey(dns_peer_t *peer, dns_name_t **retval) { 601 REQUIRE(DNS_PEER_VALID(peer)); 602 REQUIRE(retval != NULL); 603 604 if (peer->key != NULL) { 605 *retval = peer->key; 606 } 607 608 return (peer->key == NULL ? ISC_R_NOTFOUND : ISC_R_SUCCESS); 609 } 610 611 isc_result_t 612 dns_peer_setkey(dns_peer_t *peer, dns_name_t **keyval) { 613 bool exists = false; 614 615 if (peer->key != NULL) { 616 dns_name_free(peer->key, peer->mem); 617 isc_mem_put(peer->mem, peer->key, sizeof(dns_name_t)); 618 exists = true; 619 } 620 621 peer->key = *keyval; 622 *keyval = NULL; 623 624 return (exists ? ISC_R_EXISTS : ISC_R_SUCCESS); 625 } 626 627 isc_result_t 628 dns_peer_setkeybycharp(dns_peer_t *peer, const char *keyval) { 629 isc_buffer_t b; 630 dns_fixedname_t fname; 631 dns_name_t *name; 632 isc_result_t result; 633 634 dns_fixedname_init(&fname); 635 isc_buffer_constinit(&b, keyval, strlen(keyval)); 636 isc_buffer_add(&b, strlen(keyval)); 637 result = dns_name_fromtext(dns_fixedname_name(&fname), &b, dns_rootname, 638 0, NULL); 639 if (result != ISC_R_SUCCESS) { 640 return (result); 641 } 642 643 name = isc_mem_get(peer->mem, sizeof(dns_name_t)); 644 645 dns_name_init(name, NULL); 646 dns_name_dup(dns_fixedname_name(&fname), peer->mem, name); 647 648 result = dns_peer_setkey(peer, &name); 649 if (result != ISC_R_SUCCESS) { 650 isc_mem_put(peer->mem, name, sizeof(dns_name_t)); 651 } 652 653 return (result); 654 } 655 656 isc_result_t 657 dns_peer_settransfersource(dns_peer_t *peer, 658 const isc_sockaddr_t *transfer_source) { 659 REQUIRE(DNS_PEER_VALID(peer)); 660 661 if (peer->transfer_source != NULL) { 662 isc_mem_put(peer->mem, peer->transfer_source, 663 sizeof(*peer->transfer_source)); 664 peer->transfer_source = NULL; 665 } 666 if (transfer_source != NULL) { 667 peer->transfer_source = 668 isc_mem_get(peer->mem, sizeof(*peer->transfer_source)); 669 670 *peer->transfer_source = *transfer_source; 671 } 672 return (ISC_R_SUCCESS); 673 } 674 675 isc_result_t 676 dns_peer_gettransfersource(dns_peer_t *peer, isc_sockaddr_t *transfer_source) { 677 REQUIRE(DNS_PEER_VALID(peer)); 678 REQUIRE(transfer_source != NULL); 679 680 if (peer->transfer_source == NULL) { 681 return (ISC_R_NOTFOUND); 682 } 683 *transfer_source = *peer->transfer_source; 684 return (ISC_R_SUCCESS); 685 } 686 687 isc_result_t 688 dns_peer_setnotifysource(dns_peer_t *peer, 689 const isc_sockaddr_t *notify_source) { 690 REQUIRE(DNS_PEER_VALID(peer)); 691 692 if (peer->notify_source != NULL) { 693 isc_mem_put(peer->mem, peer->notify_source, 694 sizeof(*peer->notify_source)); 695 peer->notify_source = NULL; 696 } 697 if (notify_source != NULL) { 698 peer->notify_source = isc_mem_get(peer->mem, 699 sizeof(*peer->notify_source)); 700 701 *peer->notify_source = *notify_source; 702 } 703 return (ISC_R_SUCCESS); 704 } 705 706 isc_result_t 707 dns_peer_getnotifysource(dns_peer_t *peer, isc_sockaddr_t *notify_source) { 708 REQUIRE(DNS_PEER_VALID(peer)); 709 REQUIRE(notify_source != NULL); 710 711 if (peer->notify_source == NULL) { 712 return (ISC_R_NOTFOUND); 713 } 714 *notify_source = *peer->notify_source; 715 return (ISC_R_SUCCESS); 716 } 717 718 isc_result_t 719 dns_peer_setquerysource(dns_peer_t *peer, const isc_sockaddr_t *query_source) { 720 REQUIRE(DNS_PEER_VALID(peer)); 721 722 if (peer->query_source != NULL) { 723 isc_mem_put(peer->mem, peer->query_source, 724 sizeof(*peer->query_source)); 725 peer->query_source = NULL; 726 } 727 if (query_source != NULL) { 728 peer->query_source = isc_mem_get(peer->mem, 729 sizeof(*peer->query_source)); 730 731 *peer->query_source = *query_source; 732 } 733 return (ISC_R_SUCCESS); 734 } 735 736 isc_result_t 737 dns_peer_getquerysource(dns_peer_t *peer, isc_sockaddr_t *query_source) { 738 REQUIRE(DNS_PEER_VALID(peer)); 739 REQUIRE(query_source != NULL); 740 741 if (peer->query_source == NULL) { 742 return (ISC_R_NOTFOUND); 743 } 744 *query_source = *peer->query_source; 745 return (ISC_R_SUCCESS); 746 } 747 748 isc_result_t 749 dns_peer_setudpsize(dns_peer_t *peer, uint16_t udpsize) { 750 bool existed; 751 752 REQUIRE(DNS_PEER_VALID(peer)); 753 754 existed = DNS_BIT_CHECK(SERVER_UDPSIZE_BIT, &peer->bitflags); 755 756 peer->udpsize = udpsize; 757 DNS_BIT_SET(SERVER_UDPSIZE_BIT, &peer->bitflags); 758 759 return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS); 760 } 761 762 isc_result_t 763 dns_peer_getudpsize(dns_peer_t *peer, uint16_t *udpsize) { 764 REQUIRE(DNS_PEER_VALID(peer)); 765 REQUIRE(udpsize != NULL); 766 767 if (DNS_BIT_CHECK(SERVER_UDPSIZE_BIT, &peer->bitflags)) { 768 *udpsize = peer->udpsize; 769 return (ISC_R_SUCCESS); 770 } else { 771 return (ISC_R_NOTFOUND); 772 } 773 } 774 775 isc_result_t 776 dns_peer_setmaxudp(dns_peer_t *peer, uint16_t maxudp) { 777 bool existed; 778 779 REQUIRE(DNS_PEER_VALID(peer)); 780 781 existed = DNS_BIT_CHECK(SERVER_MAXUDP_BIT, &peer->bitflags); 782 783 peer->maxudp = maxudp; 784 DNS_BIT_SET(SERVER_MAXUDP_BIT, &peer->bitflags); 785 786 return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS); 787 } 788 789 isc_result_t 790 dns_peer_getmaxudp(dns_peer_t *peer, uint16_t *maxudp) { 791 REQUIRE(DNS_PEER_VALID(peer)); 792 REQUIRE(maxudp != NULL); 793 794 if (DNS_BIT_CHECK(SERVER_MAXUDP_BIT, &peer->bitflags)) { 795 *maxudp = peer->maxudp; 796 return (ISC_R_SUCCESS); 797 } else { 798 return (ISC_R_NOTFOUND); 799 } 800 } 801 802 isc_result_t 803 dns_peer_setpadding(dns_peer_t *peer, uint16_t padding) { 804 bool existed; 805 806 REQUIRE(DNS_PEER_VALID(peer)); 807 808 existed = DNS_BIT_CHECK(SERVER_PADDING_BIT, &peer->bitflags); 809 810 if (padding > 512) { 811 padding = 512; 812 } 813 peer->padding = padding; 814 DNS_BIT_SET(SERVER_PADDING_BIT, &peer->bitflags); 815 816 return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS); 817 } 818 819 isc_result_t 820 dns_peer_getpadding(dns_peer_t *peer, uint16_t *padding) { 821 REQUIRE(DNS_PEER_VALID(peer)); 822 REQUIRE(padding != NULL); 823 824 if (DNS_BIT_CHECK(SERVER_PADDING_BIT, &peer->bitflags)) { 825 *padding = peer->padding; 826 return (ISC_R_SUCCESS); 827 } else { 828 return (ISC_R_NOTFOUND); 829 } 830 } 831 832 isc_result_t 833 dns_peer_setnotifydscp(dns_peer_t *peer, isc_dscp_t dscp) { 834 REQUIRE(DNS_PEER_VALID(peer)); 835 REQUIRE(dscp < 64); 836 837 peer->notify_dscp = dscp; 838 DNS_BIT_SET(NOTIFY_DSCP_BIT, &peer->bitflags); 839 return (ISC_R_SUCCESS); 840 } 841 842 isc_result_t 843 dns_peer_getnotifydscp(dns_peer_t *peer, isc_dscp_t *dscpp) { 844 REQUIRE(DNS_PEER_VALID(peer)); 845 REQUIRE(dscpp != NULL); 846 847 if (DNS_BIT_CHECK(NOTIFY_DSCP_BIT, &peer->bitflags)) { 848 *dscpp = peer->notify_dscp; 849 return (ISC_R_SUCCESS); 850 } 851 return (ISC_R_NOTFOUND); 852 } 853 854 isc_result_t 855 dns_peer_settransferdscp(dns_peer_t *peer, isc_dscp_t dscp) { 856 REQUIRE(DNS_PEER_VALID(peer)); 857 REQUIRE(dscp < 64); 858 859 peer->transfer_dscp = dscp; 860 DNS_BIT_SET(TRANSFER_DSCP_BIT, &peer->bitflags); 861 return (ISC_R_SUCCESS); 862 } 863 864 isc_result_t 865 dns_peer_gettransferdscp(dns_peer_t *peer, isc_dscp_t *dscpp) { 866 REQUIRE(DNS_PEER_VALID(peer)); 867 REQUIRE(dscpp != NULL); 868 869 if (DNS_BIT_CHECK(TRANSFER_DSCP_BIT, &peer->bitflags)) { 870 *dscpp = peer->transfer_dscp; 871 return (ISC_R_SUCCESS); 872 } 873 return (ISC_R_NOTFOUND); 874 } 875 876 isc_result_t 877 dns_peer_setquerydscp(dns_peer_t *peer, isc_dscp_t dscp) { 878 REQUIRE(DNS_PEER_VALID(peer)); 879 REQUIRE(dscp < 64); 880 881 peer->query_dscp = dscp; 882 DNS_BIT_SET(QUERY_DSCP_BIT, &peer->bitflags); 883 return (ISC_R_SUCCESS); 884 } 885 886 isc_result_t 887 dns_peer_getquerydscp(dns_peer_t *peer, isc_dscp_t *dscpp) { 888 REQUIRE(DNS_PEER_VALID(peer)); 889 REQUIRE(dscpp != NULL); 890 891 if (DNS_BIT_CHECK(QUERY_DSCP_BIT, &peer->bitflags)) { 892 *dscpp = peer->query_dscp; 893 return (ISC_R_SUCCESS); 894 } 895 return (ISC_R_NOTFOUND); 896 } 897 898 isc_result_t 899 dns_peer_setednsversion(dns_peer_t *peer, uint8_t ednsversion) { 900 REQUIRE(DNS_PEER_VALID(peer)); 901 902 peer->ednsversion = ednsversion; 903 DNS_BIT_SET(EDNS_VERSION_BIT, &peer->bitflags); 904 905 return (ISC_R_SUCCESS); 906 } 907 908 isc_result_t 909 dns_peer_getednsversion(dns_peer_t *peer, uint8_t *ednsversion) { 910 REQUIRE(DNS_PEER_VALID(peer)); 911 REQUIRE(ednsversion != NULL); 912 913 if (DNS_BIT_CHECK(EDNS_VERSION_BIT, &peer->bitflags)) { 914 *ednsversion = peer->ednsversion; 915 return (ISC_R_SUCCESS); 916 } else { 917 return (ISC_R_NOTFOUND); 918 } 919 } 920