1 /* $NetBSD: peer.c,v 1.10 2023/01/25 21:43: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
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
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
dns_peerlist_attach(dns_peerlist_t * source,dns_peerlist_t ** target)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
dns_peerlist_detach(dns_peerlist_t ** list)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
peerlist_delete(dns_peerlist_t ** list)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
dns_peerlist_addpeer(dns_peerlist_t * peers,dns_peer_t * peer)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
dns_peerlist_peerbyaddr(dns_peerlist_t * servers,const isc_netaddr_t * addr,dns_peer_t ** retval)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
dns_peerlist_currpeer(dns_peerlist_t * peers,dns_peer_t ** retval)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
dns_peer_new(isc_mem_t * mem,const isc_netaddr_t * addr,dns_peer_t ** peerptr)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
dns_peer_newprefix(isc_mem_t * mem,const isc_netaddr_t * addr,unsigned int prefixlen,dns_peer_t ** peerptr)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
dns_peer_attach(dns_peer_t * source,dns_peer_t ** target)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
dns_peer_detach(dns_peer_t ** peer)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
peer_delete(dns_peer_t ** peer)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
dns_peer_setbogus(dns_peer_t * peer,bool newval)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
dns_peer_getbogus(dns_peer_t * peer,bool * retval)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
dns_peer_setprovideixfr(dns_peer_t * peer,bool newval)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
dns_peer_getprovideixfr(dns_peer_t * peer,bool * retval)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
dns_peer_setrequestixfr(dns_peer_t * peer,bool newval)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
dns_peer_getrequestixfr(dns_peer_t * peer,bool * retval)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
dns_peer_setsupportedns(dns_peer_t * peer,bool newval)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
dns_peer_getsupportedns(dns_peer_t * peer,bool * retval)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
dns_peer_setrequestnsid(dns_peer_t * peer,bool newval)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
dns_peer_getrequestnsid(dns_peer_t * peer,bool * retval)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
dns_peer_setsendcookie(dns_peer_t * peer,bool newval)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
dns_peer_getsendcookie(dns_peer_t * peer,bool * retval)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
dns_peer_setrequestexpire(dns_peer_t * peer,bool newval)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
dns_peer_getrequestexpire(dns_peer_t * peer,bool * retval)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
dns_peer_setforcetcp(dns_peer_t * peer,bool newval)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
dns_peer_getforcetcp(dns_peer_t * peer,bool * retval)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
dns_peer_settcpkeepalive(dns_peer_t * peer,bool newval)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
dns_peer_gettcpkeepalive(dns_peer_t * peer,bool * retval)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
dns_peer_settransfers(dns_peer_t * peer,uint32_t newval)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
dns_peer_gettransfers(dns_peer_t * peer,uint32_t * retval)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
dns_peer_settransferformat(dns_peer_t * peer,dns_transfer_format_t newval)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
dns_peer_gettransferformat(dns_peer_t * peer,dns_transfer_format_t * retval)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
dns_peer_getkey(dns_peer_t * peer,dns_name_t ** retval)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
dns_peer_setkey(dns_peer_t * peer,dns_name_t ** keyval)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
dns_peer_setkeybycharp(dns_peer_t * peer,const char * keyval)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
dns_peer_settransfersource(dns_peer_t * peer,const isc_sockaddr_t * transfer_source)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
dns_peer_gettransfersource(dns_peer_t * peer,isc_sockaddr_t * transfer_source)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
dns_peer_setnotifysource(dns_peer_t * peer,const isc_sockaddr_t * notify_source)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
dns_peer_getnotifysource(dns_peer_t * peer,isc_sockaddr_t * notify_source)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
dns_peer_setquerysource(dns_peer_t * peer,const isc_sockaddr_t * query_source)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
dns_peer_getquerysource(dns_peer_t * peer,isc_sockaddr_t * query_source)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
dns_peer_setudpsize(dns_peer_t * peer,uint16_t udpsize)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
dns_peer_getudpsize(dns_peer_t * peer,uint16_t * udpsize)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
dns_peer_setmaxudp(dns_peer_t * peer,uint16_t maxudp)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
dns_peer_getmaxudp(dns_peer_t * peer,uint16_t * maxudp)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
dns_peer_setpadding(dns_peer_t * peer,uint16_t padding)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
dns_peer_getpadding(dns_peer_t * peer,uint16_t * padding)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
dns_peer_setnotifydscp(dns_peer_t * peer,isc_dscp_t dscp)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
dns_peer_getnotifydscp(dns_peer_t * peer,isc_dscp_t * dscpp)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
dns_peer_settransferdscp(dns_peer_t * peer,isc_dscp_t dscp)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
dns_peer_gettransferdscp(dns_peer_t * peer,isc_dscp_t * dscpp)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
dns_peer_setquerydscp(dns_peer_t * peer,isc_dscp_t dscp)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
dns_peer_getquerydscp(dns_peer_t * peer,isc_dscp_t * dscpp)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
dns_peer_setednsversion(dns_peer_t * peer,uint8_t ednsversion)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
dns_peer_getednsversion(dns_peer_t * peer,uint8_t * ednsversion)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