contrib/bind-9.5.2/lib/dns/peer.c

   1 /*
   2  * Copyright (C) 2004-2008  Internet Systems Consortium, Inc. ("ISC")
   3  * Copyright (C) 2000, 2001, 2003  Internet Software Consortium.
   4  *
   5  * Permission to use, copy, modify, and/or distribute this software for any
   6  * purpose with or without fee is hereby granted, provided that the above
   7  * copyright notice and this permission notice appear in all copies.
   8  *
   9  * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
  10  * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
  11  * AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
  12  * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
  13  * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
  14  * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  15  * PERFORMANCE OF THIS SOFTWARE.
  16  */
  17
  18 /* $Id: peer.c,v 1.29.128.2 2008/04/03 06:08:27 tbox Exp $ */
  19
  20 /*! \file */
  21
  22 #include <config.h>
  23
  24 #include <isc/mem.h>
  25 #include <isc/string.h>
  26 #include <isc/util.h>
  27 #include <isc/sockaddr.h>
  28
  29 #include <dns/bit.h>
  30 #include <dns/fixedname.h>
  31 #include <dns/name.h>
  32 #include <dns/peer.h>
  33
  34 /*%
  35  * Bit positions in the dns_peer_t structure flags field
  36  */
  37 #define BOGUS_BIT                       0
  38 #define SERVER_TRANSFER_FORMAT_BIT      1
  39 #define TRANSFERS_BIT                   2
  40 #define PROVIDE_IXFR_BIT                3
  41 #define REQUEST_IXFR_BIT                4
  42 #define SUPPORT_EDNS_BIT                5
  43 #define SERVER_UDPSIZE_BIT              6
  44 #define SERVER_MAXUDP_BIT               7
  45 #define REQUEST_NSID_BIT                8
  46
  47 static void
  48 peerlist_delete(dns_peerlist_t **list);
  49
  50 static void
  51 peer_delete(dns_peer_t **peer);
  52
  53 isc_result_t
  54 dns_peerlist_new(isc_mem_t *mem, dns_peerlist_t **list) {
  55         dns_peerlist_t *l;
  56
  57         REQUIRE(list != NULL);
  58
  59         l = isc_mem_get(mem, sizeof(*l));
  60         if (l == NULL)
  61                 return (ISC_R_NOMEMORY);
  62
  63         ISC_LIST_INIT(l->elements);
  64         l->mem = mem;
  65         l->refs = 1;
  66         l->magic = DNS_PEERLIST_MAGIC;
  67
  68         *list = l;
  69
  70         return (ISC_R_SUCCESS);
  71 }
  72
  73 void
  74 dns_peerlist_attach(dns_peerlist_t *source, dns_peerlist_t **target) {
  75         REQUIRE(DNS_PEERLIST_VALID(source));
  76         REQUIRE(target != NULL);
  77         REQUIRE(*target == NULL);
  78
  79         source->refs++;
  80
  81         ENSURE(source->refs != 0xffffffffU);
  82
  83         *target = source;
  84 }
  85
  86 void
  87 dns_peerlist_detach(dns_peerlist_t **list) {
  88         dns_peerlist_t *plist;
  89
  90         REQUIRE(list != NULL);
  91         REQUIRE(*list != NULL);
  92         REQUIRE(DNS_PEERLIST_VALID(*list));
  93
  94         plist = *list;
  95         *list = NULL;
  96
  97         REQUIRE(plist->refs > 0);
  98
  99         plist->refs--;
 100
 101         if (plist->refs == 0)
 102                 peerlist_delete(&plist);
 103 }
 104
 105 static void
 106 peerlist_delete(dns_peerlist_t **list) {
 107         dns_peerlist_t *l;
 108         dns_peer_t *server, *stmp;
 109
 110         REQUIRE(list != NULL);
 111         REQUIRE(DNS_PEERLIST_VALID(*list));
 112
 113         l = *list;
 114
 115         REQUIRE(l->refs == 0);
 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         *list = NULL;
 129 }
 130
 131 void
 132 dns_peerlist_addpeer(dns_peerlist_t *peers, dns_peer_t *peer) {
 133         dns_peer_t *p = NULL;
 134
 135         dns_peer_attach(peer, &p);
 136
 137         /*
 138          * More specifics to front of list.
 139          */
 140         for (p = ISC_LIST_HEAD(peers->elements);
 141              p != NULL;
 142              p = ISC_LIST_NEXT(p, next))
 143                 if (p->prefixlen < peer->prefixlen)
 144                         break;
 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,
 155                         isc_netaddr_t *addr, dns_peer_t **retval)
 156 {
 157         dns_peer_t *server;
 158         isc_result_t res;
 159
 160         REQUIRE(retval != NULL);
 161         REQUIRE(DNS_PEERLIST_VALID(servers));
 162
 163         server = ISC_LIST_HEAD(servers->elements);
 164         while (server != NULL) {
 165                 if (isc_netaddr_eqprefix(addr, &server->address,
 166                                          server->prefixlen))
 167                         break;
 168
 169                 server = ISC_LIST_NEXT(server, next);
 170         }
 171
 172         if (server != NULL) {
 173                 *retval = server;
 174                 res = ISC_R_SUCCESS;
 175         } else {
 176                 res = ISC_R_NOTFOUND;
 177         }
 178
 179         return (res);
 180 }
 181
 182
 183
 184 isc_result_t
 185 dns_peerlist_currpeer(dns_peerlist_t *peers, dns_peer_t **retval) {
 186         dns_peer_t *p = NULL;
 187
 188         p = ISC_LIST_TAIL(peers->elements);
 189
 190         dns_peer_attach(p, retval);
 191
 192         return (ISC_R_SUCCESS);
 193 }
 194
 195 isc_result_t
 196 dns_peer_new(isc_mem_t *mem, isc_netaddr_t *addr, dns_peer_t **peerptr) {
 197         unsigned int prefixlen = 0;
 198
 199         REQUIRE(peerptr != NULL);
 200         switch(addr->family) {
 201         case AF_INET:
 202                 prefixlen = 32;
 203                 break;
 204         case AF_INET6:
 205                  prefixlen = 128;
 206                 break;
 207         default:
 208                 INSIST(0);
 209         }
 210
 211         return (dns_peer_newprefix(mem, addr, prefixlen, peerptr));
 212 }
 213
 214 isc_result_t
 215 dns_peer_newprefix(isc_mem_t *mem, isc_netaddr_t *addr, unsigned int prefixlen,
 216                    dns_peer_t **peerptr)
 217 {
 218         dns_peer_t *peer;
 219
 220         REQUIRE(peerptr != NULL);
 221
 222         peer = isc_mem_get(mem, sizeof(*peer));
 223         if (peer == NULL)
 224                 return (ISC_R_NOMEMORY);
 225
 226         peer->magic = DNS_PEER_MAGIC;
 227         peer->address = *addr;
 228         peer->prefixlen = prefixlen;
 229         peer->mem = mem;
 230         peer->bogus = ISC_FALSE;
 231         peer->transfer_format = dns_one_answer;
 232         peer->transfers = 0;
 233         peer->request_ixfr = ISC_FALSE;
 234         peer->provide_ixfr = ISC_FALSE;
 235         peer->key = NULL;
 236         peer->refs = 1;
 237         peer->transfer_source = NULL;
 238         peer->notify_source = NULL;
 239         peer->query_source = NULL;
 240
 241         memset(&peer->bitflags, 0x0, sizeof(peer->bitflags));
 242
 243         ISC_LINK_INIT(peer, next);
 244
 245         *peerptr = peer;
 246
 247         return (ISC_R_SUCCESS);
 248 }
 249
 250 void
 251 dns_peer_attach(dns_peer_t *source, dns_peer_t **target) {
 252         REQUIRE(DNS_PEER_VALID(source));
 253         REQUIRE(target != NULL);
 254         REQUIRE(*target == NULL);
 255
 256         source->refs++;
 257
 258         ENSURE(source->refs != 0xffffffffU);
 259
 260         *target = source;
 261 }
 262
 263 void
 264 dns_peer_detach(dns_peer_t **peer) {
 265         dns_peer_t *p;
 266
 267         REQUIRE(peer != NULL);
 268         REQUIRE(*peer != NULL);
 269         REQUIRE(DNS_PEER_VALID(*peer));
 270
 271         p = *peer;
 272
 273         REQUIRE(p->refs > 0);
 274
 275         *peer = NULL;
 276         p->refs--;
 277
 278         if (p->refs == 0)
 279                 peer_delete(&p);
 280 }
 281
 282 static void
 283 peer_delete(dns_peer_t **peer) {
 284         dns_peer_t *p;
 285         isc_mem_t *mem;
 286
 287         REQUIRE(peer != NULL);
 288         REQUIRE(DNS_PEER_VALID(*peer));
 289
 290         p = *peer;
 291
 292         REQUIRE(p->refs == 0);
 293
 294         mem = p->mem;
 295         p->mem = NULL;
 296         p->magic = 0;
 297
 298         if (p->key != NULL) {
 299                 dns_name_free(p->key, mem);
 300                 isc_mem_put(mem, p->key, sizeof(dns_name_t));
 301         }
 302
 303         if (p->transfer_source != NULL) {
 304                 isc_mem_put(mem, p->transfer_source,
 305                             sizeof(*p->transfer_source));
 306         }
 307
 308         isc_mem_put(mem, p, sizeof(*p));
 309
 310         *peer = NULL;
 311 }
 312
 313 isc_result_t
 314 dns_peer_setbogus(dns_peer_t *peer, isc_boolean_t newval) {
 315         isc_boolean_t existed;
 316
 317         REQUIRE(DNS_PEER_VALID(peer));
 318
 319         existed = DNS_BIT_CHECK(BOGUS_BIT, &peer->bitflags);
 320
 321         peer->bogus = newval;
 322         DNS_BIT_SET(BOGUS_BIT, &peer->bitflags);
 323
 324         return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS);
 325 }
 326
 327 isc_result_t
 328 dns_peer_getbogus(dns_peer_t *peer, isc_boolean_t *retval) {
 329         REQUIRE(DNS_PEER_VALID(peer));
 330         REQUIRE(retval != NULL);
 331
 332         if (DNS_BIT_CHECK(BOGUS_BIT, &peer->bitflags)) {
 333                 *retval = peer->bogus;
 334                 return (ISC_R_SUCCESS);
 335         } else
 336                 return (ISC_R_NOTFOUND);
 337 }
 338
 339
 340 isc_result_t
 341 dns_peer_setprovideixfr(dns_peer_t *peer, isc_boolean_t newval) {
 342         isc_boolean_t existed;
 343
 344         REQUIRE(DNS_PEER_VALID(peer));
 345
 346         existed = DNS_BIT_CHECK(PROVIDE_IXFR_BIT, &peer->bitflags);
 347
 348         peer->provide_ixfr = newval;
 349         DNS_BIT_SET(PROVIDE_IXFR_BIT, &peer->bitflags);
 350
 351         return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS);
 352 }
 353
 354 isc_result_t
 355 dns_peer_getprovideixfr(dns_peer_t *peer, isc_boolean_t *retval) {
 356         REQUIRE(DNS_PEER_VALID(peer));
 357         REQUIRE(retval != NULL);
 358
 359         if (DNS_BIT_CHECK(PROVIDE_IXFR_BIT, &peer->bitflags)) {
 360                 *retval = peer->provide_ixfr;
 361                 return (ISC_R_SUCCESS);
 362         } else {
 363                 return (ISC_R_NOTFOUND);
 364         }
 365 }
 366
 367 isc_result_t
 368 dns_peer_setrequestixfr(dns_peer_t *peer, isc_boolean_t newval) {
 369         isc_boolean_t existed;
 370
 371         REQUIRE(DNS_PEER_VALID(peer));
 372
 373         existed = DNS_BIT_CHECK(REQUEST_IXFR_BIT, &peer->bitflags);
 374
 375         peer->request_ixfr = newval;
 376         DNS_BIT_SET(REQUEST_IXFR_BIT, &peer->bitflags);
 377
 378         return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS);
 379 }
 380
 381 isc_result_t
 382 dns_peer_getrequestixfr(dns_peer_t *peer, isc_boolean_t *retval) {
 383         REQUIRE(DNS_PEER_VALID(peer));
 384         REQUIRE(retval != NULL);
 385
 386         if (DNS_BIT_CHECK(REQUEST_IXFR_BIT, &peer->bitflags)) {
 387                 *retval = peer->request_ixfr;
 388                 return (ISC_R_SUCCESS);
 389         } else
 390                 return (ISC_R_NOTFOUND);
 391 }
 392
 393 isc_result_t
 394 dns_peer_setsupportedns(dns_peer_t *peer, isc_boolean_t newval) {
 395         isc_boolean_t existed;
 396
 397         REQUIRE(DNS_PEER_VALID(peer));
 398
 399         existed = DNS_BIT_CHECK(SUPPORT_EDNS_BIT, &peer->bitflags);
 400
 401         peer->support_edns = newval;
 402         DNS_BIT_SET(SUPPORT_EDNS_BIT, &peer->bitflags);
 403
 404         return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS);
 405 }
 406
 407 isc_result_t
 408 dns_peer_getsupportedns(dns_peer_t *peer, isc_boolean_t *retval) {
 409         REQUIRE(DNS_PEER_VALID(peer));
 410         REQUIRE(retval != NULL);
 411
 412         if (DNS_BIT_CHECK(SUPPORT_EDNS_BIT, &peer->bitflags)) {
 413                 *retval = peer->support_edns;
 414                 return (ISC_R_SUCCESS);
 415         } else
 416                 return (ISC_R_NOTFOUND);
 417 }
 418
 419 isc_result_t
 420 dns_peer_setrequestnsid(dns_peer_t *peer, isc_boolean_t newval) {
 421         isc_boolean_t existed;
 422
 423         REQUIRE(DNS_PEER_VALID(peer));
 424
 425         existed = DNS_BIT_CHECK(REQUEST_NSID_BIT, &peer->bitflags);
 426
 427         peer->request_nsid = newval;
 428         DNS_BIT_SET(REQUEST_NSID_BIT, &peer->bitflags);
 429
 430         return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS);
 431 }
 432
 433 isc_result_t
 434 dns_peer_getrequestnsid(dns_peer_t *peer, isc_boolean_t *retval) {
 435         REQUIRE(DNS_PEER_VALID(peer));
 436         REQUIRE(retval != NULL);
 437
 438         if (DNS_BIT_CHECK(REQUEST_NSID_BIT, &peer->bitflags)) {
 439                 *retval = peer->request_nsid;
 440                 return (ISC_R_SUCCESS);
 441         } else
 442                 return (ISC_R_NOTFOUND);
 443 }
 444
 445 isc_result_t
 446 dns_peer_settransfers(dns_peer_t *peer, isc_uint32_t newval) {
 447         isc_boolean_t existed;
 448
 449         REQUIRE(DNS_PEER_VALID(peer));
 450
 451         existed = DNS_BIT_CHECK(TRANSFERS_BIT, &peer->bitflags);
 452
 453         peer->transfers = newval;
 454         DNS_BIT_SET(TRANSFERS_BIT, &peer->bitflags);
 455
 456         return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS);
 457 }
 458
 459 isc_result_t
 460 dns_peer_gettransfers(dns_peer_t *peer, isc_uint32_t *retval) {
 461         REQUIRE(DNS_PEER_VALID(peer));
 462         REQUIRE(retval != NULL);
 463
 464         if (DNS_BIT_CHECK(TRANSFERS_BIT, &peer->bitflags)) {
 465                 *retval = peer->transfers;
 466                 return (ISC_R_SUCCESS);
 467         } else {
 468                 return (ISC_R_NOTFOUND);
 469         }
 470 }
 471
 472 isc_result_t
 473 dns_peer_settransferformat(dns_peer_t *peer, dns_transfer_format_t newval) {
 474         isc_boolean_t existed;
 475
 476         REQUIRE(DNS_PEER_VALID(peer));
 477
 478         existed = DNS_BIT_CHECK(SERVER_TRANSFER_FORMAT_BIT,
 479                                  &peer->bitflags);
 480
 481         peer->transfer_format = newval;
 482         DNS_BIT_SET(SERVER_TRANSFER_FORMAT_BIT, &peer->bitflags);
 483
 484         return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS);
 485 }
 486
 487 isc_result_t
 488 dns_peer_gettransferformat(dns_peer_t *peer, dns_transfer_format_t *retval) {
 489         REQUIRE(DNS_PEER_VALID(peer));
 490         REQUIRE(retval != NULL);
 491
 492         if (DNS_BIT_CHECK(SERVER_TRANSFER_FORMAT_BIT, &peer->bitflags)) {
 493                 *retval = peer->transfer_format;
 494                 return (ISC_R_SUCCESS);
 495         } else {
 496                 return (ISC_R_NOTFOUND);
 497         }
 498 }
 499
 500 isc_result_t
 501 dns_peer_getkey(dns_peer_t *peer, dns_name_t **retval) {
 502         REQUIRE(DNS_PEER_VALID(peer));
 503         REQUIRE(retval != NULL);
 504
 505         if (peer->key != NULL) {
 506                 *retval = peer->key;
 507         }
 508
 509         return (peer->key == NULL ? ISC_R_NOTFOUND : ISC_R_SUCCESS);
 510 }
 511
 512 isc_result_t
 513 dns_peer_setkey(dns_peer_t *peer, dns_name_t **keyval) {
 514         isc_boolean_t exists = ISC_FALSE;
 515
 516         if (peer->key != NULL) {
 517                 dns_name_free(peer->key, peer->mem);
 518                 isc_mem_put(peer->mem, peer->key, sizeof(dns_name_t));
 519                 exists = ISC_TRUE;
 520         }
 521
 522         peer->key = *keyval;
 523         *keyval = NULL;
 524
 525         return (exists ? ISC_R_EXISTS : ISC_R_SUCCESS);
 526 }
 527
 528 isc_result_t
 529 dns_peer_setkeybycharp(dns_peer_t *peer, const char *keyval) {
 530         isc_buffer_t b;
 531         dns_fixedname_t fname;
 532         dns_name_t *name;
 533         isc_result_t result;
 534
 535         dns_fixedname_init(&fname);
 536         isc_buffer_init(&b, keyval, strlen(keyval));
 537         isc_buffer_add(&b, strlen(keyval));
 538         result = dns_name_fromtext(dns_fixedname_name(&fname), &b,
 539                                    dns_rootname, ISC_FALSE, NULL);
 540         if (result != ISC_R_SUCCESS)
 541                 return (result);
 542
 543         name = isc_mem_get(peer->mem, sizeof(dns_name_t));
 544         if (name == NULL)
 545                 return (ISC_R_NOMEMORY);
 546
 547         dns_name_init(name, NULL);
 548         result = dns_name_dup(dns_fixedname_name(&fname), peer->mem, name);
 549         if (result != ISC_R_SUCCESS) {
 550                 isc_mem_put(peer->mem, name, sizeof(dns_name_t));
 551                 return (result);
 552         }
 553
 554         result = dns_peer_setkey(peer, &name);
 555         if (result != ISC_R_SUCCESS)
 556                 isc_mem_put(peer->mem, name, sizeof(dns_name_t));
 557
 558         return (result);
 559 }
 560
 561 isc_result_t
 562 dns_peer_settransfersource(dns_peer_t *peer,
 563                            const isc_sockaddr_t *transfer_source)
 564 {
 565         REQUIRE(DNS_PEER_VALID(peer));
 566
 567         if (peer->transfer_source != NULL) {
 568                 isc_mem_put(peer->mem, peer->transfer_source,
 569                             sizeof(*peer->transfer_source));
 570                 peer->transfer_source = NULL;
 571         }
 572         if (transfer_source != NULL) {
 573                 peer->transfer_source = isc_mem_get(peer->mem,
 574                                                 sizeof(*peer->transfer_source));
 575                 if (peer->transfer_source == NULL)
 576                         return (ISC_R_NOMEMORY);
 577
 578                 *peer->transfer_source = *transfer_source;
 579         }
 580         return (ISC_R_SUCCESS);
 581 }
 582
 583 isc_result_t
 584 dns_peer_gettransfersource(dns_peer_t *peer, isc_sockaddr_t *transfer_source) {
 585         REQUIRE(DNS_PEER_VALID(peer));
 586         REQUIRE(transfer_source != NULL);
 587
 588         if (peer->transfer_source == NULL)
 589                 return (ISC_R_NOTFOUND);
 590         *transfer_source = *peer->transfer_source;
 591         return (ISC_R_SUCCESS);
 592 }
 593
 594 isc_result_t
 595 dns_peer_setnotifysource(dns_peer_t *peer,
 596                          const isc_sockaddr_t *notify_source)
 597 {
 598         REQUIRE(DNS_PEER_VALID(peer));
 599
 600         if (peer->notify_source != NULL) {
 601                 isc_mem_put(peer->mem, peer->notify_source,
 602                             sizeof(*peer->notify_source));
 603                 peer->notify_source = NULL;
 604         }
 605         if (notify_source != NULL) {
 606                 peer->notify_source = isc_mem_get(peer->mem,
 607                                                 sizeof(*peer->notify_source));
 608                 if (peer->notify_source == NULL)
 609                         return (ISC_R_NOMEMORY);
 610
 611                 *peer->notify_source = *notify_source;
 612         }
 613         return (ISC_R_SUCCESS);
 614 }
 615
 616 isc_result_t
 617 dns_peer_getnotifysource(dns_peer_t *peer, isc_sockaddr_t *notify_source) {
 618         REQUIRE(DNS_PEER_VALID(peer));
 619         REQUIRE(notify_source != NULL);
 620
 621         if (peer->notify_source == NULL)
 622                 return (ISC_R_NOTFOUND);
 623         *notify_source = *peer->notify_source;
 624         return (ISC_R_SUCCESS);
 625 }
 626
 627 isc_result_t
 628 dns_peer_setquerysource(dns_peer_t *peer, const isc_sockaddr_t *query_source) {
 629         REQUIRE(DNS_PEER_VALID(peer));
 630
 631         if (peer->query_source != NULL) {
 632                 isc_mem_put(peer->mem, peer->query_source,
 633                             sizeof(*peer->query_source));
 634                 peer->query_source = NULL;
 635         }
 636         if (query_source != NULL) {
 637                 peer->query_source = isc_mem_get(peer->mem,
 638                                                 sizeof(*peer->query_source));
 639                 if (peer->query_source == NULL)
 640                         return (ISC_R_NOMEMORY);
 641
 642                 *peer->query_source = *query_source;
 643         }
 644         return (ISC_R_SUCCESS);
 645 }
 646
 647 isc_result_t
 648 dns_peer_getquerysource(dns_peer_t *peer, isc_sockaddr_t *query_source) {
 649         REQUIRE(DNS_PEER_VALID(peer));
 650         REQUIRE(query_source != NULL);
 651
 652         if (peer->query_source == NULL)
 653                 return (ISC_R_NOTFOUND);
 654         *query_source = *peer->query_source;
 655         return (ISC_R_SUCCESS);
 656 }
 657
 658 isc_result_t
 659 dns_peer_setudpsize(dns_peer_t *peer, isc_uint16_t udpsize) {
 660         isc_boolean_t existed;
 661
 662         REQUIRE(DNS_PEER_VALID(peer));
 663
 664         existed = DNS_BIT_CHECK(SERVER_UDPSIZE_BIT, &peer->bitflags);
 665
 666         peer->udpsize = udpsize;
 667         DNS_BIT_SET(SERVER_UDPSIZE_BIT, &peer->bitflags);
 668
 669         return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS);
 670 }
 671
 672 isc_result_t
 673 dns_peer_getudpsize(dns_peer_t *peer, isc_uint16_t *udpsize) {
 674
 675         REQUIRE(DNS_PEER_VALID(peer));
 676         REQUIRE(udpsize != NULL);
 677
 678         if (DNS_BIT_CHECK(SERVER_UDPSIZE_BIT, &peer->bitflags)) {
 679                 *udpsize = peer->udpsize;
 680                 return (ISC_R_SUCCESS);
 681         } else {
 682                 return (ISC_R_NOTFOUND);
 683         }
 684 }
 685
 686 isc_result_t
 687 dns_peer_setmaxudp(dns_peer_t *peer, isc_uint16_t maxudp) {
 688         isc_boolean_t existed;
 689
 690         REQUIRE(DNS_PEER_VALID(peer));
 691
 692         existed = DNS_BIT_CHECK(SERVER_MAXUDP_BIT, &peer->bitflags);
 693
 694         peer->maxudp = maxudp;
 695         DNS_BIT_SET(SERVER_MAXUDP_BIT, &peer->bitflags);
 696
 697         return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS);
 698 }
 699
 700 isc_result_t
 701 dns_peer_getmaxudp(dns_peer_t *peer, isc_uint16_t *maxudp) {
 702
 703         REQUIRE(DNS_PEER_VALID(peer));
 704         REQUIRE(maxudp != NULL);
 705
 706         if (DNS_BIT_CHECK(SERVER_MAXUDP_BIT, &peer->bitflags)) {
 707                 *maxudp = peer->maxudp;
 708                 return (ISC_R_SUCCESS);
 709         } else {
 710                 return (ISC_R_NOTFOUND);
 711         }
 712 }