/*
 * Copyright (C) Internet Systems Consortium, Inc. ("ISC")
 *
 * SPDX-License-Identifier: MPL-2.0
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, you can obtain one at https://mozilla.org/MPL/2.0/.
 *
 * See the COPYRIGHT file distributed with this work for additional
 * information regarding copyright ownership.
 */

/*! \file */

#include <inttypes.h>
#include <stdbool.h>

#include <isc/mem.h>
#include <isc/sockaddr.h>
#include <isc/string.h>
#include <isc/util.h>

#include <dns/bit.h>
#include <dns/fixedname.h>
#include <dns/name.h>
#include <dns/peer.h>

/***
 *** Types
 ***/

struct dns_peerlist {
	unsigned int magic;
	isc_refcount_t refs;

	isc_mem_t *mem;

	ISC_LIST(dns_peer_t) elements;
};

struct dns_peer {
	unsigned int magic;
	isc_refcount_t refs;

	isc_mem_t *mem;

	isc_netaddr_t address;
	unsigned int prefixlen;
	bool bogus;
	dns_transfer_format_t transfer_format;
	uint32_t transfers;
	bool support_ixfr;
	bool provide_ixfr;
	bool request_ixfr;
	bool support_edns;
	bool request_nsid;
	bool send_cookie;
	bool request_expire;
	bool force_tcp;
	bool tcp_keepalive;
	bool check_axfr_id;
	dns_name_t *key;
	isc_sockaddr_t *transfer_source;
	isc_sockaddr_t *notify_source;
	isc_sockaddr_t *query_source;
	uint16_t udpsize;    /* receive size */
	uint16_t maxudp;     /* transmit size */
	uint16_t padding;    /* pad block size */
	uint8_t ednsversion; /* edns version */

	uint32_t bitflags;

	ISC_LINK(dns_peer_t) next;
};

/*%
 * Bit positions in the dns_peer_t structure flags field
 */
#define BOGUS_BIT		   0
#define SERVER_TRANSFER_FORMAT_BIT 1
#define TRANSFERS_BIT		   2
#define PROVIDE_IXFR_BIT	   3
#define REQUEST_IXFR_BIT	   4
#define SUPPORT_EDNS_BIT	   5
#define SERVER_UDPSIZE_BIT	   6
#define SERVER_MAXUDP_BIT	   7
#define REQUEST_NSID_BIT	   8
#define SEND_COOKIE_BIT		   9
#define REQUEST_EXPIRE_BIT	   10
#define EDNS_VERSION_BIT	   11
#define FORCE_TCP_BIT		   12
#define SERVER_PADDING_BIT	   13
#define REQUEST_TCP_KEEPALIVE_BIT  14

static void
peerlist_delete(dns_peerlist_t **list);

static void
peer_delete(dns_peer_t **peer);

isc_result_t
dns_peerlist_new(isc_mem_t *mem, dns_peerlist_t **list) {
	dns_peerlist_t *l;

	REQUIRE(list != NULL);

	l = isc_mem_get(mem, sizeof(*l));

	ISC_LIST_INIT(l->elements);
	l->mem = mem;
	isc_refcount_init(&l->refs, 1);
	l->magic = DNS_PEERLIST_MAGIC;

	*list = l;

	return (ISC_R_SUCCESS);
}

void
dns_peerlist_attach(dns_peerlist_t *source, dns_peerlist_t **target) {
	REQUIRE(DNS_PEERLIST_VALID(source));
	REQUIRE(target != NULL);
	REQUIRE(*target == NULL);

	isc_refcount_increment(&source->refs);

	*target = source;
}

void
dns_peerlist_detach(dns_peerlist_t **list) {
	dns_peerlist_t *plist;

	REQUIRE(list != NULL);
	REQUIRE(*list != NULL);
	REQUIRE(DNS_PEERLIST_VALID(*list));

	plist = *list;
	*list = NULL;

	if (isc_refcount_decrement(&plist->refs) == 1) {
		peerlist_delete(&plist);
	}
}

static void
peerlist_delete(dns_peerlist_t **list) {
	dns_peerlist_t *l;
	dns_peer_t *server, *stmp;

	REQUIRE(list != NULL);
	REQUIRE(DNS_PEERLIST_VALID(*list));

	l = *list;
	*list = NULL;

	isc_refcount_destroy(&l->refs);

	server = ISC_LIST_HEAD(l->elements);
	while (server != NULL) {
		stmp = ISC_LIST_NEXT(server, next);
		ISC_LIST_UNLINK(l->elements, server, next);
		dns_peer_detach(&server);
		server = stmp;
	}

	l->magic = 0;
	isc_mem_put(l->mem, l, sizeof(*l));
}

void
dns_peerlist_addpeer(dns_peerlist_t *peers, dns_peer_t *peer) {
	dns_peer_t *p = NULL;

	dns_peer_attach(peer, &p);

	/*
	 * More specifics to front of list.
	 */
	for (p = ISC_LIST_HEAD(peers->elements); p != NULL;
	     p = ISC_LIST_NEXT(p, next))
	{
		if (p->prefixlen < peer->prefixlen) {
			break;
		}
	}

	if (p != NULL) {
		ISC_LIST_INSERTBEFORE(peers->elements, p, peer, next);
	} else {
		ISC_LIST_APPEND(peers->elements, peer, next);
	}
}

isc_result_t
dns_peerlist_peerbyaddr(dns_peerlist_t *servers, const isc_netaddr_t *addr,
			dns_peer_t **retval) {
	dns_peer_t *server;
	isc_result_t res;

	REQUIRE(retval != NULL);
	REQUIRE(DNS_PEERLIST_VALID(servers));

	server = ISC_LIST_HEAD(servers->elements);
	while (server != NULL) {
		if (isc_netaddr_eqprefix(addr, &server->address,
					 server->prefixlen))
		{
			break;
		}

		server = ISC_LIST_NEXT(server, next);
	}

	if (server != NULL) {
		*retval = server;
		res = ISC_R_SUCCESS;
	} else {
		res = ISC_R_NOTFOUND;
	}

	return (res);
}

isc_result_t
dns_peerlist_currpeer(dns_peerlist_t *peers, dns_peer_t **retval) {
	dns_peer_t *p = NULL;

	p = ISC_LIST_TAIL(peers->elements);

	dns_peer_attach(p, retval);

	return (ISC_R_SUCCESS);
}

isc_result_t
dns_peer_new(isc_mem_t *mem, const isc_netaddr_t *addr, dns_peer_t **peerptr) {
	unsigned int prefixlen = 0;

	REQUIRE(peerptr != NULL);
	switch (addr->family) {
	case AF_INET:
		prefixlen = 32;
		break;
	case AF_INET6:
		prefixlen = 128;
		break;
	default:
		UNREACHABLE();
	}

	return (dns_peer_newprefix(mem, addr, prefixlen, peerptr));
}

isc_result_t
dns_peer_newprefix(isc_mem_t *mem, const isc_netaddr_t *addr,
		   unsigned int prefixlen, dns_peer_t **peerptr) {
	dns_peer_t *peer;

	REQUIRE(peerptr != NULL && *peerptr == NULL);

	peer = isc_mem_get(mem, sizeof(*peer));

	*peer = (dns_peer_t){
		.magic = DNS_PEER_MAGIC,
		.address = *addr,
		.prefixlen = prefixlen,
		.mem = mem,
		.transfer_format = dns_one_answer,
	};

	isc_refcount_init(&peer->refs, 1);

	ISC_LINK_INIT(peer, next);

	*peerptr = peer;

	return (ISC_R_SUCCESS);
}

void
dns_peer_attach(dns_peer_t *source, dns_peer_t **target) {
	REQUIRE(DNS_PEER_VALID(source));
	REQUIRE(target != NULL);
	REQUIRE(*target == NULL);

	isc_refcount_increment(&source->refs);

	*target = source;
}

void
dns_peer_detach(dns_peer_t **peer) {
	dns_peer_t *p;

	REQUIRE(peer != NULL);
	REQUIRE(*peer != NULL);
	REQUIRE(DNS_PEER_VALID(*peer));

	p = *peer;
	*peer = NULL;

	if (isc_refcount_decrement(&p->refs) == 1) {
		peer_delete(&p);
	}
}

static void
peer_delete(dns_peer_t **peer) {
	dns_peer_t *p;
	isc_mem_t *mem;

	REQUIRE(peer != NULL);
	REQUIRE(DNS_PEER_VALID(*peer));

	p = *peer;
	*peer = NULL;

	isc_refcount_destroy(&p->refs);

	mem = p->mem;
	p->mem = NULL;
	p->magic = 0;

	if (p->key != NULL) {
		dns_name_free(p->key, mem);
		isc_mem_put(mem, p->key, sizeof(dns_name_t));
	}

	if (p->query_source != NULL) {
		isc_mem_put(mem, p->query_source, sizeof(*p->query_source));
	}

	if (p->notify_source != NULL) {
		isc_mem_put(mem, p->notify_source, sizeof(*p->notify_source));
	}

	if (p->transfer_source != NULL) {
		isc_mem_put(mem, p->transfer_source,
			    sizeof(*p->transfer_source));
	}

	isc_mem_put(mem, p, sizeof(*p));
}

isc_result_t
dns_peer_setbogus(dns_peer_t *peer, bool newval) {
	bool existed;

	REQUIRE(DNS_PEER_VALID(peer));

	existed = DNS_BIT_CHECK(BOGUS_BIT, &peer->bitflags);

	peer->bogus = newval;
	DNS_BIT_SET(BOGUS_BIT, &peer->bitflags);

	return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS);
}

isc_result_t
dns_peer_getbogus(dns_peer_t *peer, bool *retval) {
	REQUIRE(DNS_PEER_VALID(peer));
	REQUIRE(retval != NULL);

	if (DNS_BIT_CHECK(BOGUS_BIT, &peer->bitflags)) {
		*retval = peer->bogus;
		return (ISC_R_SUCCESS);
	} else {
		return (ISC_R_NOTFOUND);
	}
}

isc_result_t
dns_peer_setprovideixfr(dns_peer_t *peer, bool newval) {
	bool existed;

	REQUIRE(DNS_PEER_VALID(peer));

	existed = DNS_BIT_CHECK(PROVIDE_IXFR_BIT, &peer->bitflags);

	peer->provide_ixfr = newval;
	DNS_BIT_SET(PROVIDE_IXFR_BIT, &peer->bitflags);

	return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS);
}

isc_result_t
dns_peer_getprovideixfr(dns_peer_t *peer, bool *retval) {
	REQUIRE(DNS_PEER_VALID(peer));
	REQUIRE(retval != NULL);

	if (DNS_BIT_CHECK(PROVIDE_IXFR_BIT, &peer->bitflags)) {
		*retval = peer->provide_ixfr;
		return (ISC_R_SUCCESS);
	} else {
		return (ISC_R_NOTFOUND);
	}
}

isc_result_t
dns_peer_setrequestixfr(dns_peer_t *peer, bool newval) {
	bool existed;

	REQUIRE(DNS_PEER_VALID(peer));

	existed = DNS_BIT_CHECK(REQUEST_IXFR_BIT, &peer->bitflags);

	peer->request_ixfr = newval;
	DNS_BIT_SET(REQUEST_IXFR_BIT, &peer->bitflags);

	return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS);
}

isc_result_t
dns_peer_getrequestixfr(dns_peer_t *peer, bool *retval) {
	REQUIRE(DNS_PEER_VALID(peer));
	REQUIRE(retval != NULL);

	if (DNS_BIT_CHECK(REQUEST_IXFR_BIT, &peer->bitflags)) {
		*retval = peer->request_ixfr;
		return (ISC_R_SUCCESS);
	} else {
		return (ISC_R_NOTFOUND);
	}
}

isc_result_t
dns_peer_setsupportedns(dns_peer_t *peer, bool newval) {
	bool existed;

	REQUIRE(DNS_PEER_VALID(peer));

	existed = DNS_BIT_CHECK(SUPPORT_EDNS_BIT, &peer->bitflags);

	peer->support_edns = newval;
	DNS_BIT_SET(SUPPORT_EDNS_BIT, &peer->bitflags);

	return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS);
}

isc_result_t
dns_peer_getsupportedns(dns_peer_t *peer, bool *retval) {
	REQUIRE(DNS_PEER_VALID(peer));
	REQUIRE(retval != NULL);

	if (DNS_BIT_CHECK(SUPPORT_EDNS_BIT, &peer->bitflags)) {
		*retval = peer->support_edns;
		return (ISC_R_SUCCESS);
	} else {
		return (ISC_R_NOTFOUND);
	}
}

isc_result_t
dns_peer_setrequestnsid(dns_peer_t *peer, bool newval) {
	bool existed;

	REQUIRE(DNS_PEER_VALID(peer));

	existed = DNS_BIT_CHECK(REQUEST_NSID_BIT, &peer->bitflags);

	peer->request_nsid = newval;
	DNS_BIT_SET(REQUEST_NSID_BIT, &peer->bitflags);

	return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS);
}

isc_result_t
dns_peer_getrequestnsid(dns_peer_t *peer, bool *retval) {
	REQUIRE(DNS_PEER_VALID(peer));
	REQUIRE(retval != NULL);

	if (DNS_BIT_CHECK(REQUEST_NSID_BIT, &peer->bitflags)) {
		*retval = peer->request_nsid;
		return (ISC_R_SUCCESS);
	} else {
		return (ISC_R_NOTFOUND);
	}
}

isc_result_t
dns_peer_setsendcookie(dns_peer_t *peer, bool newval) {
	bool existed;

	REQUIRE(DNS_PEER_VALID(peer));

	existed = DNS_BIT_CHECK(SEND_COOKIE_BIT, &peer->bitflags);

	peer->send_cookie = newval;
	DNS_BIT_SET(SEND_COOKIE_BIT, &peer->bitflags);

	return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS);
}

isc_result_t
dns_peer_getsendcookie(dns_peer_t *peer, bool *retval) {
	REQUIRE(DNS_PEER_VALID(peer));
	REQUIRE(retval != NULL);

	if (DNS_BIT_CHECK(SEND_COOKIE_BIT, &peer->bitflags)) {
		*retval = peer->send_cookie;
		return (ISC_R_SUCCESS);
	} else {
		return (ISC_R_NOTFOUND);
	}
}

isc_result_t
dns_peer_setrequestexpire(dns_peer_t *peer, bool newval) {
	bool existed;

	REQUIRE(DNS_PEER_VALID(peer));

	existed = DNS_BIT_CHECK(REQUEST_EXPIRE_BIT, &peer->bitflags);

	peer->request_expire = newval;
	DNS_BIT_SET(REQUEST_EXPIRE_BIT, &peer->bitflags);

	return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS);
}

isc_result_t
dns_peer_getrequestexpire(dns_peer_t *peer, bool *retval) {
	REQUIRE(DNS_PEER_VALID(peer));
	REQUIRE(retval != NULL);

	if (DNS_BIT_CHECK(REQUEST_EXPIRE_BIT, &peer->bitflags)) {
		*retval = peer->request_expire;
		return (ISC_R_SUCCESS);
	} else {
		return (ISC_R_NOTFOUND);
	}
}

isc_result_t
dns_peer_setforcetcp(dns_peer_t *peer, bool newval) {
	bool existed;

	REQUIRE(DNS_PEER_VALID(peer));

	existed = DNS_BIT_CHECK(FORCE_TCP_BIT, &peer->bitflags);

	peer->force_tcp = newval;
	DNS_BIT_SET(FORCE_TCP_BIT, &peer->bitflags);

	return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS);
}

isc_result_t
dns_peer_getforcetcp(dns_peer_t *peer, bool *retval) {
	REQUIRE(DNS_PEER_VALID(peer));
	REQUIRE(retval != NULL);

	if (DNS_BIT_CHECK(FORCE_TCP_BIT, &peer->bitflags)) {
		*retval = peer->force_tcp;
		return (ISC_R_SUCCESS);
	} else {
		return (ISC_R_NOTFOUND);
	}
}

isc_result_t
dns_peer_settcpkeepalive(dns_peer_t *peer, bool newval) {
	bool existed;

	REQUIRE(DNS_PEER_VALID(peer));

	existed = DNS_BIT_CHECK(REQUEST_TCP_KEEPALIVE_BIT, &peer->bitflags);

	peer->tcp_keepalive = newval;
	DNS_BIT_SET(REQUEST_TCP_KEEPALIVE_BIT, &peer->bitflags);

	return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS);
}

isc_result_t
dns_peer_gettcpkeepalive(dns_peer_t *peer, bool *retval) {
	REQUIRE(DNS_PEER_VALID(peer));
	REQUIRE(retval != NULL);

	if (DNS_BIT_CHECK(REQUEST_TCP_KEEPALIVE_BIT, &peer->bitflags)) {
		*retval = peer->tcp_keepalive;
		return (ISC_R_SUCCESS);
	} else {
		return (ISC_R_NOTFOUND);
	}
}

isc_result_t
dns_peer_settransfers(dns_peer_t *peer, uint32_t newval) {
	bool existed;

	REQUIRE(DNS_PEER_VALID(peer));

	existed = DNS_BIT_CHECK(TRANSFERS_BIT, &peer->bitflags);

	peer->transfers = newval;
	DNS_BIT_SET(TRANSFERS_BIT, &peer->bitflags);

	return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS);
}

isc_result_t
dns_peer_gettransfers(dns_peer_t *peer, uint32_t *retval) {
	REQUIRE(DNS_PEER_VALID(peer));
	REQUIRE(retval != NULL);

	if (DNS_BIT_CHECK(TRANSFERS_BIT, &peer->bitflags)) {
		*retval = peer->transfers;
		return (ISC_R_SUCCESS);
	} else {
		return (ISC_R_NOTFOUND);
	}
}

isc_result_t
dns_peer_settransferformat(dns_peer_t *peer, dns_transfer_format_t newval) {
	bool existed;

	REQUIRE(DNS_PEER_VALID(peer));

	existed = DNS_BIT_CHECK(SERVER_TRANSFER_FORMAT_BIT, &peer->bitflags);

	peer->transfer_format = newval;
	DNS_BIT_SET(SERVER_TRANSFER_FORMAT_BIT, &peer->bitflags);

	return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS);
}

isc_result_t
dns_peer_gettransferformat(dns_peer_t *peer, dns_transfer_format_t *retval) {
	REQUIRE(DNS_PEER_VALID(peer));
	REQUIRE(retval != NULL);

	if (DNS_BIT_CHECK(SERVER_TRANSFER_FORMAT_BIT, &peer->bitflags)) {
		*retval = peer->transfer_format;
		return (ISC_R_SUCCESS);
	} else {
		return (ISC_R_NOTFOUND);
	}
}

isc_result_t
dns_peer_getkey(dns_peer_t *peer, dns_name_t **retval) {
	REQUIRE(DNS_PEER_VALID(peer));
	REQUIRE(retval != NULL);

	if (peer->key != NULL) {
		*retval = peer->key;
	}

	return (peer->key == NULL ? ISC_R_NOTFOUND : ISC_R_SUCCESS);
}

isc_result_t
dns_peer_setkey(dns_peer_t *peer, dns_name_t **keyval) {
	bool exists = false;

	if (peer->key != NULL) {
		dns_name_free(peer->key, peer->mem);
		isc_mem_put(peer->mem, peer->key, sizeof(dns_name_t));
		exists = true;
	}

	peer->key = *keyval;
	*keyval = NULL;

	return (exists ? ISC_R_EXISTS : ISC_R_SUCCESS);
}

isc_result_t
dns_peer_setkeybycharp(dns_peer_t *peer, const char *keyval) {
	isc_buffer_t b;
	dns_fixedname_t fname;
	dns_name_t *name;
	isc_result_t result;

	dns_fixedname_init(&fname);
	isc_buffer_constinit(&b, keyval, strlen(keyval));
	isc_buffer_add(&b, strlen(keyval));
	result = dns_name_fromtext(dns_fixedname_name(&fname), &b, dns_rootname,
				   0, NULL);
	if (result != ISC_R_SUCCESS) {
		return (result);
	}

	name = isc_mem_get(peer->mem, sizeof(dns_name_t));

	dns_name_init(name, NULL);
	dns_name_dup(dns_fixedname_name(&fname), peer->mem, name);

	result = dns_peer_setkey(peer, &name);
	if (result != ISC_R_SUCCESS) {
		isc_mem_put(peer->mem, name, sizeof(dns_name_t));
	}

	return (result);
}

isc_result_t
dns_peer_settransfersource(dns_peer_t *peer,
			   const isc_sockaddr_t *transfer_source) {
	REQUIRE(DNS_PEER_VALID(peer));

	if (peer->transfer_source != NULL) {
		isc_mem_put(peer->mem, peer->transfer_source,
			    sizeof(*peer->transfer_source));
		peer->transfer_source = NULL;
	}
	if (transfer_source != NULL) {
		peer->transfer_source =
			isc_mem_get(peer->mem, sizeof(*peer->transfer_source));

		*peer->transfer_source = *transfer_source;
	}
	return (ISC_R_SUCCESS);
}

isc_result_t
dns_peer_gettransfersource(dns_peer_t *peer, isc_sockaddr_t *transfer_source) {
	REQUIRE(DNS_PEER_VALID(peer));
	REQUIRE(transfer_source != NULL);

	if (peer->transfer_source == NULL) {
		return (ISC_R_NOTFOUND);
	}
	*transfer_source = *peer->transfer_source;
	return (ISC_R_SUCCESS);
}

isc_result_t
dns_peer_setnotifysource(dns_peer_t *peer,
			 const isc_sockaddr_t *notify_source) {
	REQUIRE(DNS_PEER_VALID(peer));

	if (peer->notify_source != NULL) {
		isc_mem_put(peer->mem, peer->notify_source,
			    sizeof(*peer->notify_source));
		peer->notify_source = NULL;
	}
	if (notify_source != NULL) {
		peer->notify_source = isc_mem_get(peer->mem,
						  sizeof(*peer->notify_source));

		*peer->notify_source = *notify_source;
	}
	return (ISC_R_SUCCESS);
}

isc_result_t
dns_peer_getnotifysource(dns_peer_t *peer, isc_sockaddr_t *notify_source) {
	REQUIRE(DNS_PEER_VALID(peer));
	REQUIRE(notify_source != NULL);

	if (peer->notify_source == NULL) {
		return (ISC_R_NOTFOUND);
	}
	*notify_source = *peer->notify_source;
	return (ISC_R_SUCCESS);
}

isc_result_t
dns_peer_setquerysource(dns_peer_t *peer, const isc_sockaddr_t *query_source) {
	REQUIRE(DNS_PEER_VALID(peer));

	if (peer->query_source != NULL) {
		isc_mem_put(peer->mem, peer->query_source,
			    sizeof(*peer->query_source));
		peer->query_source = NULL;
	}
	if (query_source != NULL) {
		peer->query_source = isc_mem_get(peer->mem,
						 sizeof(*peer->query_source));

		*peer->query_source = *query_source;
	}
	return (ISC_R_SUCCESS);
}

isc_result_t
dns_peer_getquerysource(dns_peer_t *peer, isc_sockaddr_t *query_source) {
	REQUIRE(DNS_PEER_VALID(peer));
	REQUIRE(query_source != NULL);

	if (peer->query_source == NULL) {
		return (ISC_R_NOTFOUND);
	}
	*query_source = *peer->query_source;
	return (ISC_R_SUCCESS);
}

isc_result_t
dns_peer_setudpsize(dns_peer_t *peer, uint16_t udpsize) {
	bool existed;

	REQUIRE(DNS_PEER_VALID(peer));

	existed = DNS_BIT_CHECK(SERVER_UDPSIZE_BIT, &peer->bitflags);

	peer->udpsize = udpsize;
	DNS_BIT_SET(SERVER_UDPSIZE_BIT, &peer->bitflags);

	return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS);
}

isc_result_t
dns_peer_getudpsize(dns_peer_t *peer, uint16_t *udpsize) {
	REQUIRE(DNS_PEER_VALID(peer));
	REQUIRE(udpsize != NULL);

	if (DNS_BIT_CHECK(SERVER_UDPSIZE_BIT, &peer->bitflags)) {
		*udpsize = peer->udpsize;
		return (ISC_R_SUCCESS);
	} else {
		return (ISC_R_NOTFOUND);
	}
}

isc_result_t
dns_peer_setmaxudp(dns_peer_t *peer, uint16_t maxudp) {
	bool existed;

	REQUIRE(DNS_PEER_VALID(peer));

	existed = DNS_BIT_CHECK(SERVER_MAXUDP_BIT, &peer->bitflags);

	peer->maxudp = maxudp;
	DNS_BIT_SET(SERVER_MAXUDP_BIT, &peer->bitflags);

	return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS);
}

isc_result_t
dns_peer_getmaxudp(dns_peer_t *peer, uint16_t *maxudp) {
	REQUIRE(DNS_PEER_VALID(peer));
	REQUIRE(maxudp != NULL);

	if (DNS_BIT_CHECK(SERVER_MAXUDP_BIT, &peer->bitflags)) {
		*maxudp = peer->maxudp;
		return (ISC_R_SUCCESS);
	} else {
		return (ISC_R_NOTFOUND);
	}
}

isc_result_t
dns_peer_setpadding(dns_peer_t *peer, uint16_t padding) {
	bool existed;

	REQUIRE(DNS_PEER_VALID(peer));

	existed = DNS_BIT_CHECK(SERVER_PADDING_BIT, &peer->bitflags);

	if (padding > 512) {
		padding = 512;
	}
	peer->padding = padding;
	DNS_BIT_SET(SERVER_PADDING_BIT, &peer->bitflags);

	return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS);
}

isc_result_t
dns_peer_getpadding(dns_peer_t *peer, uint16_t *padding) {
	REQUIRE(DNS_PEER_VALID(peer));
	REQUIRE(padding != NULL);

	if (DNS_BIT_CHECK(SERVER_PADDING_BIT, &peer->bitflags)) {
		*padding = peer->padding;
		return (ISC_R_SUCCESS);
	} else {
		return (ISC_R_NOTFOUND);
	}
}

isc_result_t
dns_peer_setednsversion(dns_peer_t *peer, uint8_t ednsversion) {
	REQUIRE(DNS_PEER_VALID(peer));

	peer->ednsversion = ednsversion;
	DNS_BIT_SET(EDNS_VERSION_BIT, &peer->bitflags);

	return (ISC_R_SUCCESS);
}

isc_result_t
dns_peer_getednsversion(dns_peer_t *peer, uint8_t *ednsversion) {
	REQUIRE(DNS_PEER_VALID(peer));
	REQUIRE(ednsversion != NULL);

	if (DNS_BIT_CHECK(EDNS_VERSION_BIT, &peer->bitflags)) {
		*ednsversion = peer->ednsversion;
		return (ISC_R_SUCCESS);
	} else {
		return (ISC_R_NOTFOUND);
	}
}
