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