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
53static void
54peerlist_delete(dns_peerlist_t **list);
55
56static void
57peer_delete(dns_peer_t **peer);
58
59isc_result_t
60dns_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
77void
78dns_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
88void
89dns_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
104static void
105peerlist_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
129void
130dns_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
153isc_result_t
154dns_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
183isc_result_t
184dns_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
194isc_result_t
195dns_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
213isc_result_t
214dns_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
239void
240dns_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
250void
251dns_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
266static void
267peer_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
304isc_result_t
305dns_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
318isc_result_t
319dns_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
331isc_result_t
332dns_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
345isc_result_t
346dns_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
358isc_result_t
359dns_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
372isc_result_t
373dns_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
385isc_result_t
386dns_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
399isc_result_t
400dns_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
412isc_result_t
413dns_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
426isc_result_t
427dns_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
439isc_result_t
440dns_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
453isc_result_t
454dns_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
466isc_result_t
467dns_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
480isc_result_t
481dns_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
493isc_result_t
494dns_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
507isc_result_t
508dns_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
520isc_result_t
521dns_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
534isc_result_t
535dns_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
547isc_result_t
548dns_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
561isc_result_t
562dns_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
574isc_result_t
575dns_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
588isc_result_t
589dns_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
601isc_result_t
602dns_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
613isc_result_t
614dns_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
629isc_result_t
630dns_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
658isc_result_t
659dns_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
677isc_result_t
678dns_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
689isc_result_t
690dns_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
708isc_result_t
709dns_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
720isc_result_t
721dns_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
738isc_result_t
739dns_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
750isc_result_t
751dns_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
764isc_result_t
765dns_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
777isc_result_t
778dns_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
791isc_result_t
792dns_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
804isc_result_t
805dns_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
821isc_result_t
822dns_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
834isc_result_t
835dns_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
844isc_result_t
845dns_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
856isc_result_t
857dns_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
866isc_result_t
867dns_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
878isc_result_t
879dns_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
888isc_result_t
889dns_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
900isc_result_t
901dns_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
910isc_result_t
911dns_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