mirror of
https://github.com/isc-projects/bind9.git
synced 2026-03-14 06:32:14 -04:00
5fd93c66aa
DSCP has not been fully working since the network manager was
introduced in 9.16, and has been completely broken since 9.18.
This seems to have caused very few difficulties for anyone,
so we have now marked it as obsolete and removed the
implementation.
To ensure that old config files don't fail, the code to parse
dscp key-value pairs is still present, but a warning is logged
that the feature is obsolete and should not be used. Nothing is
done with configured values, and there is no longer any
range checking.
(cherry picked from commit 916ea26ead)
898 lines
19 KiB
C
898 lines
19 KiB
C
/*
|
|
* 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);
|
|
}
|
|
}
|