/contrib/bind9/lib/dns/peer.c

https://bitbucket.org/freebsd/freebsd-head/ · C · 712 lines · 516 code · 172 blank · 24 comment · 108 complexity · 1999e728c0859a3f9192c6581ca16992 MD5 · raw file

  1. /*
  2. * Copyright (C) 2004-2009 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. /* $Id: peer.c,v 1.33 2009/09/02 23:48:02 tbox Exp $ */
  18. /*! \file */
  19. #include <config.h>
  20. #include <isc/mem.h>
  21. #include <isc/string.h>
  22. #include <isc/util.h>
  23. #include <isc/sockaddr.h>
  24. #include <dns/bit.h>
  25. #include <dns/fixedname.h>
  26. #include <dns/name.h>
  27. #include <dns/peer.h>
  28. /*%
  29. * Bit positions in the dns_peer_t structure flags field
  30. */
  31. #define BOGUS_BIT 0
  32. #define SERVER_TRANSFER_FORMAT_BIT 1
  33. #define TRANSFERS_BIT 2
  34. #define PROVIDE_IXFR_BIT 3
  35. #define REQUEST_IXFR_BIT 4
  36. #define SUPPORT_EDNS_BIT 5
  37. #define SERVER_UDPSIZE_BIT 6
  38. #define SERVER_MAXUDP_BIT 7
  39. #define REQUEST_NSID_BIT 8
  40. static void
  41. peerlist_delete(dns_peerlist_t **list);
  42. static void
  43. peer_delete(dns_peer_t **peer);
  44. isc_result_t
  45. dns_peerlist_new(isc_mem_t *mem, dns_peerlist_t **list) {
  46. dns_peerlist_t *l;
  47. REQUIRE(list != NULL);
  48. l = isc_mem_get(mem, sizeof(*l));
  49. if (l == NULL)
  50. return (ISC_R_NOMEMORY);
  51. ISC_LIST_INIT(l->elements);
  52. l->mem = mem;
  53. l->refs = 1;
  54. l->magic = DNS_PEERLIST_MAGIC;
  55. *list = l;
  56. return (ISC_R_SUCCESS);
  57. }
  58. void
  59. dns_peerlist_attach(dns_peerlist_t *source, dns_peerlist_t **target) {
  60. REQUIRE(DNS_PEERLIST_VALID(source));
  61. REQUIRE(target != NULL);
  62. REQUIRE(*target == NULL);
  63. source->refs++;
  64. ENSURE(source->refs != 0xffffffffU);
  65. *target = source;
  66. }
  67. void
  68. dns_peerlist_detach(dns_peerlist_t **list) {
  69. dns_peerlist_t *plist;
  70. REQUIRE(list != NULL);
  71. REQUIRE(*list != NULL);
  72. REQUIRE(DNS_PEERLIST_VALID(*list));
  73. plist = *list;
  74. *list = NULL;
  75. REQUIRE(plist->refs > 0);
  76. plist->refs--;
  77. if (plist->refs == 0)
  78. peerlist_delete(&plist);
  79. }
  80. static void
  81. peerlist_delete(dns_peerlist_t **list) {
  82. dns_peerlist_t *l;
  83. dns_peer_t *server, *stmp;
  84. REQUIRE(list != NULL);
  85. REQUIRE(DNS_PEERLIST_VALID(*list));
  86. l = *list;
  87. REQUIRE(l->refs == 0);
  88. server = ISC_LIST_HEAD(l->elements);
  89. while (server != NULL) {
  90. stmp = ISC_LIST_NEXT(server, next);
  91. ISC_LIST_UNLINK(l->elements, server, next);
  92. dns_peer_detach(&server);
  93. server = stmp;
  94. }
  95. l->magic = 0;
  96. isc_mem_put(l->mem, l, sizeof(*l));
  97. *list = NULL;
  98. }
  99. void
  100. dns_peerlist_addpeer(dns_peerlist_t *peers, dns_peer_t *peer) {
  101. dns_peer_t *p = NULL;
  102. dns_peer_attach(peer, &p);
  103. /*
  104. * More specifics to front of list.
  105. */
  106. for (p = ISC_LIST_HEAD(peers->elements);
  107. p != NULL;
  108. p = ISC_LIST_NEXT(p, next))
  109. if (p->prefixlen < peer->prefixlen)
  110. break;
  111. if (p != NULL)
  112. ISC_LIST_INSERTBEFORE(peers->elements, p, peer, next);
  113. else
  114. ISC_LIST_APPEND(peers->elements, peer, next);
  115. }
  116. isc_result_t
  117. dns_peerlist_peerbyaddr(dns_peerlist_t *servers,
  118. isc_netaddr_t *addr, dns_peer_t **retval)
  119. {
  120. dns_peer_t *server;
  121. isc_result_t res;
  122. REQUIRE(retval != NULL);
  123. REQUIRE(DNS_PEERLIST_VALID(servers));
  124. server = ISC_LIST_HEAD(servers->elements);
  125. while (server != NULL) {
  126. if (isc_netaddr_eqprefix(addr, &server->address,
  127. server->prefixlen))
  128. break;
  129. server = ISC_LIST_NEXT(server, next);
  130. }
  131. if (server != NULL) {
  132. *retval = server;
  133. res = ISC_R_SUCCESS;
  134. } else {
  135. res = ISC_R_NOTFOUND;
  136. }
  137. return (res);
  138. }
  139. isc_result_t
  140. dns_peerlist_currpeer(dns_peerlist_t *peers, dns_peer_t **retval) {
  141. dns_peer_t *p = NULL;
  142. p = ISC_LIST_TAIL(peers->elements);
  143. dns_peer_attach(p, retval);
  144. return (ISC_R_SUCCESS);
  145. }
  146. isc_result_t
  147. dns_peer_new(isc_mem_t *mem, isc_netaddr_t *addr, dns_peer_t **peerptr) {
  148. unsigned int prefixlen = 0;
  149. REQUIRE(peerptr != NULL);
  150. switch(addr->family) {
  151. case AF_INET:
  152. prefixlen = 32;
  153. break;
  154. case AF_INET6:
  155. prefixlen = 128;
  156. break;
  157. default:
  158. INSIST(0);
  159. }
  160. return (dns_peer_newprefix(mem, addr, prefixlen, peerptr));
  161. }
  162. isc_result_t
  163. dns_peer_newprefix(isc_mem_t *mem, isc_netaddr_t *addr, unsigned int prefixlen,
  164. dns_peer_t **peerptr)
  165. {
  166. dns_peer_t *peer;
  167. REQUIRE(peerptr != NULL);
  168. peer = isc_mem_get(mem, sizeof(*peer));
  169. if (peer == NULL)
  170. return (ISC_R_NOMEMORY);
  171. peer->magic = DNS_PEER_MAGIC;
  172. peer->address = *addr;
  173. peer->prefixlen = prefixlen;
  174. peer->mem = mem;
  175. peer->bogus = ISC_FALSE;
  176. peer->transfer_format = dns_one_answer;
  177. peer->transfers = 0;
  178. peer->request_ixfr = ISC_FALSE;
  179. peer->provide_ixfr = ISC_FALSE;
  180. peer->key = NULL;
  181. peer->refs = 1;
  182. peer->transfer_source = NULL;
  183. peer->notify_source = NULL;
  184. peer->query_source = NULL;
  185. memset(&peer->bitflags, 0x0, sizeof(peer->bitflags));
  186. ISC_LINK_INIT(peer, next);
  187. *peerptr = peer;
  188. return (ISC_R_SUCCESS);
  189. }
  190. void
  191. dns_peer_attach(dns_peer_t *source, dns_peer_t **target) {
  192. REQUIRE(DNS_PEER_VALID(source));
  193. REQUIRE(target != NULL);
  194. REQUIRE(*target == NULL);
  195. source->refs++;
  196. ENSURE(source->refs != 0xffffffffU);
  197. *target = source;
  198. }
  199. void
  200. dns_peer_detach(dns_peer_t **peer) {
  201. dns_peer_t *p;
  202. REQUIRE(peer != NULL);
  203. REQUIRE(*peer != NULL);
  204. REQUIRE(DNS_PEER_VALID(*peer));
  205. p = *peer;
  206. REQUIRE(p->refs > 0);
  207. *peer = NULL;
  208. p->refs--;
  209. if (p->refs == 0)
  210. peer_delete(&p);
  211. }
  212. static void
  213. peer_delete(dns_peer_t **peer) {
  214. dns_peer_t *p;
  215. isc_mem_t *mem;
  216. REQUIRE(peer != NULL);
  217. REQUIRE(DNS_PEER_VALID(*peer));
  218. p = *peer;
  219. REQUIRE(p->refs == 0);
  220. mem = p->mem;
  221. p->mem = NULL;
  222. p->magic = 0;
  223. if (p->key != NULL) {
  224. dns_name_free(p->key, mem);
  225. isc_mem_put(mem, p->key, sizeof(dns_name_t));
  226. }
  227. if (p->transfer_source != NULL) {
  228. isc_mem_put(mem, p->transfer_source,
  229. sizeof(*p->transfer_source));
  230. }
  231. isc_mem_put(mem, p, sizeof(*p));
  232. *peer = NULL;
  233. }
  234. isc_result_t
  235. dns_peer_setbogus(dns_peer_t *peer, isc_boolean_t newval) {
  236. isc_boolean_t existed;
  237. REQUIRE(DNS_PEER_VALID(peer));
  238. existed = DNS_BIT_CHECK(BOGUS_BIT, &peer->bitflags);
  239. peer->bogus = newval;
  240. DNS_BIT_SET(BOGUS_BIT, &peer->bitflags);
  241. return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS);
  242. }
  243. isc_result_t
  244. dns_peer_getbogus(dns_peer_t *peer, isc_boolean_t *retval) {
  245. REQUIRE(DNS_PEER_VALID(peer));
  246. REQUIRE(retval != NULL);
  247. if (DNS_BIT_CHECK(BOGUS_BIT, &peer->bitflags)) {
  248. *retval = peer->bogus;
  249. return (ISC_R_SUCCESS);
  250. } else
  251. return (ISC_R_NOTFOUND);
  252. }
  253. isc_result_t
  254. dns_peer_setprovideixfr(dns_peer_t *peer, isc_boolean_t newval) {
  255. isc_boolean_t existed;
  256. REQUIRE(DNS_PEER_VALID(peer));
  257. existed = DNS_BIT_CHECK(PROVIDE_IXFR_BIT, &peer->bitflags);
  258. peer->provide_ixfr = newval;
  259. DNS_BIT_SET(PROVIDE_IXFR_BIT, &peer->bitflags);
  260. return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS);
  261. }
  262. isc_result_t
  263. dns_peer_getprovideixfr(dns_peer_t *peer, isc_boolean_t *retval) {
  264. REQUIRE(DNS_PEER_VALID(peer));
  265. REQUIRE(retval != NULL);
  266. if (DNS_BIT_CHECK(PROVIDE_IXFR_BIT, &peer->bitflags)) {
  267. *retval = peer->provide_ixfr;
  268. return (ISC_R_SUCCESS);
  269. } else {
  270. return (ISC_R_NOTFOUND);
  271. }
  272. }
  273. isc_result_t
  274. dns_peer_setrequestixfr(dns_peer_t *peer, isc_boolean_t newval) {
  275. isc_boolean_t existed;
  276. REQUIRE(DNS_PEER_VALID(peer));
  277. existed = DNS_BIT_CHECK(REQUEST_IXFR_BIT, &peer->bitflags);
  278. peer->request_ixfr = newval;
  279. DNS_BIT_SET(REQUEST_IXFR_BIT, &peer->bitflags);
  280. return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS);
  281. }
  282. isc_result_t
  283. dns_peer_getrequestixfr(dns_peer_t *peer, isc_boolean_t *retval) {
  284. REQUIRE(DNS_PEER_VALID(peer));
  285. REQUIRE(retval != NULL);
  286. if (DNS_BIT_CHECK(REQUEST_IXFR_BIT, &peer->bitflags)) {
  287. *retval = peer->request_ixfr;
  288. return (ISC_R_SUCCESS);
  289. } else
  290. return (ISC_R_NOTFOUND);
  291. }
  292. isc_result_t
  293. dns_peer_setsupportedns(dns_peer_t *peer, isc_boolean_t newval) {
  294. isc_boolean_t existed;
  295. REQUIRE(DNS_PEER_VALID(peer));
  296. existed = DNS_BIT_CHECK(SUPPORT_EDNS_BIT, &peer->bitflags);
  297. peer->support_edns = newval;
  298. DNS_BIT_SET(SUPPORT_EDNS_BIT, &peer->bitflags);
  299. return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS);
  300. }
  301. isc_result_t
  302. dns_peer_getsupportedns(dns_peer_t *peer, isc_boolean_t *retval) {
  303. REQUIRE(DNS_PEER_VALID(peer));
  304. REQUIRE(retval != NULL);
  305. if (DNS_BIT_CHECK(SUPPORT_EDNS_BIT, &peer->bitflags)) {
  306. *retval = peer->support_edns;
  307. return (ISC_R_SUCCESS);
  308. } else
  309. return (ISC_R_NOTFOUND);
  310. }
  311. isc_result_t
  312. dns_peer_setrequestnsid(dns_peer_t *peer, isc_boolean_t newval) {
  313. isc_boolean_t existed;
  314. REQUIRE(DNS_PEER_VALID(peer));
  315. existed = DNS_BIT_CHECK(REQUEST_NSID_BIT, &peer->bitflags);
  316. peer->request_nsid = newval;
  317. DNS_BIT_SET(REQUEST_NSID_BIT, &peer->bitflags);
  318. return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS);
  319. }
  320. isc_result_t
  321. dns_peer_getrequestnsid(dns_peer_t *peer, isc_boolean_t *retval) {
  322. REQUIRE(DNS_PEER_VALID(peer));
  323. REQUIRE(retval != NULL);
  324. if (DNS_BIT_CHECK(REQUEST_NSID_BIT, &peer->bitflags)) {
  325. *retval = peer->request_nsid;
  326. return (ISC_R_SUCCESS);
  327. } else
  328. return (ISC_R_NOTFOUND);
  329. }
  330. isc_result_t
  331. dns_peer_settransfers(dns_peer_t *peer, isc_uint32_t newval) {
  332. isc_boolean_t existed;
  333. REQUIRE(DNS_PEER_VALID(peer));
  334. existed = DNS_BIT_CHECK(TRANSFERS_BIT, &peer->bitflags);
  335. peer->transfers = newval;
  336. DNS_BIT_SET(TRANSFERS_BIT, &peer->bitflags);
  337. return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS);
  338. }
  339. isc_result_t
  340. dns_peer_gettransfers(dns_peer_t *peer, isc_uint32_t *retval) {
  341. REQUIRE(DNS_PEER_VALID(peer));
  342. REQUIRE(retval != NULL);
  343. if (DNS_BIT_CHECK(TRANSFERS_BIT, &peer->bitflags)) {
  344. *retval = peer->transfers;
  345. return (ISC_R_SUCCESS);
  346. } else {
  347. return (ISC_R_NOTFOUND);
  348. }
  349. }
  350. isc_result_t
  351. dns_peer_settransferformat(dns_peer_t *peer, dns_transfer_format_t newval) {
  352. isc_boolean_t existed;
  353. REQUIRE(DNS_PEER_VALID(peer));
  354. existed = DNS_BIT_CHECK(SERVER_TRANSFER_FORMAT_BIT,
  355. &peer->bitflags);
  356. peer->transfer_format = newval;
  357. DNS_BIT_SET(SERVER_TRANSFER_FORMAT_BIT, &peer->bitflags);
  358. return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS);
  359. }
  360. isc_result_t
  361. dns_peer_gettransferformat(dns_peer_t *peer, dns_transfer_format_t *retval) {
  362. REQUIRE(DNS_PEER_VALID(peer));
  363. REQUIRE(retval != NULL);
  364. if (DNS_BIT_CHECK(SERVER_TRANSFER_FORMAT_BIT, &peer->bitflags)) {
  365. *retval = peer->transfer_format;
  366. return (ISC_R_SUCCESS);
  367. } else {
  368. return (ISC_R_NOTFOUND);
  369. }
  370. }
  371. isc_result_t
  372. dns_peer_getkey(dns_peer_t *peer, dns_name_t **retval) {
  373. REQUIRE(DNS_PEER_VALID(peer));
  374. REQUIRE(retval != NULL);
  375. if (peer->key != NULL) {
  376. *retval = peer->key;
  377. }
  378. return (peer->key == NULL ? ISC_R_NOTFOUND : ISC_R_SUCCESS);
  379. }
  380. isc_result_t
  381. dns_peer_setkey(dns_peer_t *peer, dns_name_t **keyval) {
  382. isc_boolean_t exists = ISC_FALSE;
  383. if (peer->key != NULL) {
  384. dns_name_free(peer->key, peer->mem);
  385. isc_mem_put(peer->mem, peer->key, sizeof(dns_name_t));
  386. exists = ISC_TRUE;
  387. }
  388. peer->key = *keyval;
  389. *keyval = NULL;
  390. return (exists ? ISC_R_EXISTS : ISC_R_SUCCESS);
  391. }
  392. isc_result_t
  393. dns_peer_setkeybycharp(dns_peer_t *peer, const char *keyval) {
  394. isc_buffer_t b;
  395. dns_fixedname_t fname;
  396. dns_name_t *name;
  397. isc_result_t result;
  398. dns_fixedname_init(&fname);
  399. isc_buffer_init(&b, keyval, strlen(keyval));
  400. isc_buffer_add(&b, strlen(keyval));
  401. result = dns_name_fromtext(dns_fixedname_name(&fname), &b,
  402. dns_rootname, 0, NULL);
  403. if (result != ISC_R_SUCCESS)
  404. return (result);
  405. name = isc_mem_get(peer->mem, sizeof(dns_name_t));
  406. if (name == NULL)
  407. return (ISC_R_NOMEMORY);
  408. dns_name_init(name, NULL);
  409. result = dns_name_dup(dns_fixedname_name(&fname), peer->mem, name);
  410. if (result != ISC_R_SUCCESS) {
  411. isc_mem_put(peer->mem, name, sizeof(dns_name_t));
  412. return (result);
  413. }
  414. result = dns_peer_setkey(peer, &name);
  415. if (result != ISC_R_SUCCESS)
  416. isc_mem_put(peer->mem, name, sizeof(dns_name_t));
  417. return (result);
  418. }
  419. isc_result_t
  420. dns_peer_settransfersource(dns_peer_t *peer,
  421. const isc_sockaddr_t *transfer_source)
  422. {
  423. REQUIRE(DNS_PEER_VALID(peer));
  424. if (peer->transfer_source != NULL) {
  425. isc_mem_put(peer->mem, peer->transfer_source,
  426. sizeof(*peer->transfer_source));
  427. peer->transfer_source = NULL;
  428. }
  429. if (transfer_source != NULL) {
  430. peer->transfer_source = isc_mem_get(peer->mem,
  431. sizeof(*peer->transfer_source));
  432. if (peer->transfer_source == NULL)
  433. return (ISC_R_NOMEMORY);
  434. *peer->transfer_source = *transfer_source;
  435. }
  436. return (ISC_R_SUCCESS);
  437. }
  438. isc_result_t
  439. dns_peer_gettransfersource(dns_peer_t *peer, isc_sockaddr_t *transfer_source) {
  440. REQUIRE(DNS_PEER_VALID(peer));
  441. REQUIRE(transfer_source != NULL);
  442. if (peer->transfer_source == NULL)
  443. return (ISC_R_NOTFOUND);
  444. *transfer_source = *peer->transfer_source;
  445. return (ISC_R_SUCCESS);
  446. }
  447. isc_result_t
  448. dns_peer_setnotifysource(dns_peer_t *peer,
  449. const isc_sockaddr_t *notify_source)
  450. {
  451. REQUIRE(DNS_PEER_VALID(peer));
  452. if (peer->notify_source != NULL) {
  453. isc_mem_put(peer->mem, peer->notify_source,
  454. sizeof(*peer->notify_source));
  455. peer->notify_source = NULL;
  456. }
  457. if (notify_source != NULL) {
  458. peer->notify_source = isc_mem_get(peer->mem,
  459. sizeof(*peer->notify_source));
  460. if (peer->notify_source == NULL)
  461. return (ISC_R_NOMEMORY);
  462. *peer->notify_source = *notify_source;
  463. }
  464. return (ISC_R_SUCCESS);
  465. }
  466. isc_result_t
  467. dns_peer_getnotifysource(dns_peer_t *peer, isc_sockaddr_t *notify_source) {
  468. REQUIRE(DNS_PEER_VALID(peer));
  469. REQUIRE(notify_source != NULL);
  470. if (peer->notify_source == NULL)
  471. return (ISC_R_NOTFOUND);
  472. *notify_source = *peer->notify_source;
  473. return (ISC_R_SUCCESS);
  474. }
  475. isc_result_t
  476. dns_peer_setquerysource(dns_peer_t *peer, const isc_sockaddr_t *query_source) {
  477. REQUIRE(DNS_PEER_VALID(peer));
  478. if (peer->query_source != NULL) {
  479. isc_mem_put(peer->mem, peer->query_source,
  480. sizeof(*peer->query_source));
  481. peer->query_source = NULL;
  482. }
  483. if (query_source != NULL) {
  484. peer->query_source = isc_mem_get(peer->mem,
  485. sizeof(*peer->query_source));
  486. if (peer->query_source == NULL)
  487. return (ISC_R_NOMEMORY);
  488. *peer->query_source = *query_source;
  489. }
  490. return (ISC_R_SUCCESS);
  491. }
  492. isc_result_t
  493. dns_peer_getquerysource(dns_peer_t *peer, isc_sockaddr_t *query_source) {
  494. REQUIRE(DNS_PEER_VALID(peer));
  495. REQUIRE(query_source != NULL);
  496. if (peer->query_source == NULL)
  497. return (ISC_R_NOTFOUND);
  498. *query_source = *peer->query_source;
  499. return (ISC_R_SUCCESS);
  500. }
  501. isc_result_t
  502. dns_peer_setudpsize(dns_peer_t *peer, isc_uint16_t udpsize) {
  503. isc_boolean_t existed;
  504. REQUIRE(DNS_PEER_VALID(peer));
  505. existed = DNS_BIT_CHECK(SERVER_UDPSIZE_BIT, &peer->bitflags);
  506. peer->udpsize = udpsize;
  507. DNS_BIT_SET(SERVER_UDPSIZE_BIT, &peer->bitflags);
  508. return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS);
  509. }
  510. isc_result_t
  511. dns_peer_getudpsize(dns_peer_t *peer, isc_uint16_t *udpsize) {
  512. REQUIRE(DNS_PEER_VALID(peer));
  513. REQUIRE(udpsize != NULL);
  514. if (DNS_BIT_CHECK(SERVER_UDPSIZE_BIT, &peer->bitflags)) {
  515. *udpsize = peer->udpsize;
  516. return (ISC_R_SUCCESS);
  517. } else {
  518. return (ISC_R_NOTFOUND);
  519. }
  520. }
  521. isc_result_t
  522. dns_peer_setmaxudp(dns_peer_t *peer, isc_uint16_t maxudp) {
  523. isc_boolean_t existed;
  524. REQUIRE(DNS_PEER_VALID(peer));
  525. existed = DNS_BIT_CHECK(SERVER_MAXUDP_BIT, &peer->bitflags);
  526. peer->maxudp = maxudp;
  527. DNS_BIT_SET(SERVER_MAXUDP_BIT, &peer->bitflags);
  528. return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS);
  529. }
  530. isc_result_t
  531. dns_peer_getmaxudp(dns_peer_t *peer, isc_uint16_t *maxudp) {
  532. REQUIRE(DNS_PEER_VALID(peer));
  533. REQUIRE(maxudp != NULL);
  534. if (DNS_BIT_CHECK(SERVER_MAXUDP_BIT, &peer->bitflags)) {
  535. *maxudp = peer->maxudp;
  536. return (ISC_R_SUCCESS);
  537. } else {
  538. return (ISC_R_NOTFOUND);
  539. }
  540. }