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