2 * Copyright (C) 2004, 2006 Internet Systems Consortium, Inc. ("ISC")
3 * Copyright (C) 2000, 2001, 2003 Internet Software Consortium.
5 * Permission to use, copy, modify, and distribute this software for any
6 * purpose with or without fee is hereby granted, provided that the above
7 * copyright notice and this permission notice appear in all copies.
9 * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
10 * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
11 * AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
12 * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
13 * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
14 * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
15 * PERFORMANCE OF THIS SOFTWARE.
18 /* $Id: peer.c,v 1.14.2.1.10.6 2006/03/02 00:37:20 marka Exp $ */
23 #include <isc/string.h>
25 #include <isc/sockaddr.h>
28 #include <dns/fixedname.h>
33 * Bit positions in the dns_peer_t structure flags field
36 #define SERVER_TRANSFER_FORMAT_BIT 1
37 #define TRANSFERS_BIT 2
38 #define PROVIDE_IXFR_BIT 3
39 #define REQUEST_IXFR_BIT 4
40 #define SUPPORT_EDNS_BIT 5
43 peerlist_delete(dns_peerlist_t **list);
46 peer_delete(dns_peer_t **peer);
49 dns_peerlist_new(isc_mem_t *mem, dns_peerlist_t **list) {
52 REQUIRE(list != NULL);
54 l = isc_mem_get(mem, sizeof(*l));
56 return (ISC_R_NOMEMORY);
58 ISC_LIST_INIT(l->elements);
61 l->magic = DNS_PEERLIST_MAGIC;
65 return (ISC_R_SUCCESS);
70 dns_peerlist_attach(dns_peerlist_t *source, dns_peerlist_t **target) {
71 REQUIRE(DNS_PEERLIST_VALID(source));
72 REQUIRE(target != NULL);
73 REQUIRE(*target == NULL);
77 ENSURE(source->refs != 0xffffffffU);
83 dns_peerlist_detach(dns_peerlist_t **list) {
84 dns_peerlist_t *plist;
86 REQUIRE(list != NULL);
87 REQUIRE(*list != NULL);
88 REQUIRE(DNS_PEERLIST_VALID(*list));
93 REQUIRE(plist->refs > 0);
98 peerlist_delete(&plist);
102 peerlist_delete(dns_peerlist_t **list) {
104 dns_peer_t *server, *stmp;
106 REQUIRE(list != NULL);
107 REQUIRE(DNS_PEERLIST_VALID(*list));
111 REQUIRE(l->refs == 0);
113 server = ISC_LIST_HEAD(l->elements);
114 while (server != NULL) {
115 stmp = ISC_LIST_NEXT(server, next);
116 ISC_LIST_UNLINK(l->elements, server, next);
117 dns_peer_detach(&server);
122 isc_mem_put(l->mem, l, sizeof(*l));
128 dns_peerlist_addpeer(dns_peerlist_t *peers, dns_peer_t *peer) {
129 dns_peer_t *p = NULL;
131 dns_peer_attach(peer, &p);
133 ISC_LIST_APPEND(peers->elements, peer, next);
137 dns_peerlist_peerbyaddr(dns_peerlist_t *servers,
138 isc_netaddr_t *addr, dns_peer_t **retval)
143 REQUIRE(retval != NULL);
144 REQUIRE(DNS_PEERLIST_VALID(servers));
146 server = ISC_LIST_HEAD(servers->elements);
147 while (server != NULL) {
148 if (isc_netaddr_equal(addr, &server->address))
151 server = ISC_LIST_NEXT(server, next);
154 if (server != NULL) {
158 res = ISC_R_NOTFOUND;
167 dns_peerlist_currpeer(dns_peerlist_t *peers, dns_peer_t **retval) {
168 dns_peer_t *p = NULL;
170 p = ISC_LIST_TAIL(peers->elements);
172 dns_peer_attach(p, retval);
174 return (ISC_R_SUCCESS);
178 dns_peer_new(isc_mem_t *mem, isc_netaddr_t *addr, dns_peer_t **peerptr) {
181 REQUIRE(peerptr != NULL);
183 peer = isc_mem_get(mem, sizeof(*peer));
185 return (ISC_R_NOMEMORY);
187 peer->magic = DNS_PEER_MAGIC;
188 peer->address = *addr;
190 peer->bogus = ISC_FALSE;
191 peer->transfer_format = dns_one_answer;
193 peer->request_ixfr = ISC_FALSE;
194 peer->provide_ixfr = ISC_FALSE;
197 peer->transfer_source = NULL;
199 memset(&peer->bitflags, 0x0, sizeof(peer->bitflags));
201 ISC_LINK_INIT(peer, next);
205 return (ISC_R_SUCCESS);
209 dns_peer_attach(dns_peer_t *source, dns_peer_t **target) {
210 REQUIRE(DNS_PEER_VALID(source));
211 REQUIRE(target != NULL);
212 REQUIRE(*target == NULL);
216 ENSURE(source->refs != 0xffffffffU);
222 dns_peer_detach(dns_peer_t **peer) {
225 REQUIRE(peer != NULL);
226 REQUIRE(*peer != NULL);
227 REQUIRE(DNS_PEER_VALID(*peer));
231 REQUIRE(p->refs > 0);
241 peer_delete(dns_peer_t **peer) {
245 REQUIRE(peer != NULL);
246 REQUIRE(DNS_PEER_VALID(*peer));
250 REQUIRE(p->refs == 0);
256 if (p->key != NULL) {
257 dns_name_free(p->key, mem);
258 isc_mem_put(mem, p->key, sizeof(dns_name_t));
261 if (p->transfer_source != NULL) {
262 isc_mem_put(mem, p->transfer_source,
263 sizeof(*p->transfer_source));
266 isc_mem_put(mem, p, sizeof(*p));
272 dns_peer_setbogus(dns_peer_t *peer, isc_boolean_t newval) {
273 isc_boolean_t existed;
275 REQUIRE(DNS_PEER_VALID(peer));
277 existed = DNS_BIT_CHECK(BOGUS_BIT, &peer->bitflags);
279 peer->bogus = newval;
280 DNS_BIT_SET(BOGUS_BIT, &peer->bitflags);
282 return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS);
286 dns_peer_getbogus(dns_peer_t *peer, isc_boolean_t *retval) {
287 REQUIRE(DNS_PEER_VALID(peer));
288 REQUIRE(retval != NULL);
290 if (DNS_BIT_CHECK(BOGUS_BIT, &peer->bitflags)) {
291 *retval = peer->bogus;
292 return (ISC_R_SUCCESS);
294 return (ISC_R_NOTFOUND);
299 dns_peer_setprovideixfr(dns_peer_t *peer, isc_boolean_t newval) {
300 isc_boolean_t existed;
302 REQUIRE(DNS_PEER_VALID(peer));
304 existed = DNS_BIT_CHECK(PROVIDE_IXFR_BIT, &peer->bitflags);
306 peer->provide_ixfr = newval;
307 DNS_BIT_SET(PROVIDE_IXFR_BIT, &peer->bitflags);
309 return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS);
313 dns_peer_getprovideixfr(dns_peer_t *peer, isc_boolean_t *retval) {
314 REQUIRE(DNS_PEER_VALID(peer));
315 REQUIRE(retval != NULL);
317 if (DNS_BIT_CHECK(PROVIDE_IXFR_BIT, &peer->bitflags)) {
318 *retval = peer->provide_ixfr;
319 return (ISC_R_SUCCESS);
321 return (ISC_R_NOTFOUND);
326 dns_peer_setrequestixfr(dns_peer_t *peer, isc_boolean_t newval) {
327 isc_boolean_t existed;
329 REQUIRE(DNS_PEER_VALID(peer));
331 existed = DNS_BIT_CHECK(REQUEST_IXFR_BIT, &peer->bitflags);
333 peer->request_ixfr = newval;
334 DNS_BIT_SET(REQUEST_IXFR_BIT, &peer->bitflags);
336 return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS);
340 dns_peer_getrequestixfr(dns_peer_t *peer, isc_boolean_t *retval) {
341 REQUIRE(DNS_PEER_VALID(peer));
342 REQUIRE(retval != NULL);
344 if (DNS_BIT_CHECK(REQUEST_IXFR_BIT, &peer->bitflags)) {
345 *retval = peer->request_ixfr;
346 return (ISC_R_SUCCESS);
348 return (ISC_R_NOTFOUND);
352 dns_peer_setsupportedns(dns_peer_t *peer, isc_boolean_t newval) {
353 isc_boolean_t existed;
355 REQUIRE(DNS_PEER_VALID(peer));
357 existed = DNS_BIT_CHECK(SUPPORT_EDNS_BIT, &peer->bitflags);
359 peer->support_edns = newval;
360 DNS_BIT_SET(SUPPORT_EDNS_BIT, &peer->bitflags);
362 return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS);
366 dns_peer_getsupportedns(dns_peer_t *peer, isc_boolean_t *retval) {
367 REQUIRE(DNS_PEER_VALID(peer));
368 REQUIRE(retval != NULL);
370 if (DNS_BIT_CHECK(SUPPORT_EDNS_BIT, &peer->bitflags)) {
371 *retval = peer->support_edns;
372 return (ISC_R_SUCCESS);
374 return (ISC_R_NOTFOUND);
378 dns_peer_settransfers(dns_peer_t *peer, isc_uint32_t newval) {
379 isc_boolean_t existed;
381 REQUIRE(DNS_PEER_VALID(peer));
383 existed = DNS_BIT_CHECK(TRANSFERS_BIT, &peer->bitflags);
385 peer->transfers = newval;
386 DNS_BIT_SET(TRANSFERS_BIT, &peer->bitflags);
388 return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS);
392 dns_peer_gettransfers(dns_peer_t *peer, isc_uint32_t *retval) {
393 REQUIRE(DNS_PEER_VALID(peer));
394 REQUIRE(retval != NULL);
396 if (DNS_BIT_CHECK(TRANSFERS_BIT, &peer->bitflags)) {
397 *retval = peer->transfers;
398 return (ISC_R_SUCCESS);
400 return (ISC_R_NOTFOUND);
405 dns_peer_settransferformat(dns_peer_t *peer, dns_transfer_format_t newval) {
406 isc_boolean_t existed;
408 REQUIRE(DNS_PEER_VALID(peer));
410 existed = DNS_BIT_CHECK(SERVER_TRANSFER_FORMAT_BIT,
413 peer->transfer_format = newval;
414 DNS_BIT_SET(SERVER_TRANSFER_FORMAT_BIT, &peer->bitflags);
416 return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS);
420 dns_peer_gettransferformat(dns_peer_t *peer, dns_transfer_format_t *retval) {
421 REQUIRE(DNS_PEER_VALID(peer));
422 REQUIRE(retval != NULL);
424 if (DNS_BIT_CHECK(SERVER_TRANSFER_FORMAT_BIT, &peer->bitflags)) {
425 *retval = peer->transfer_format;
426 return (ISC_R_SUCCESS);
428 return (ISC_R_NOTFOUND);
433 dns_peer_getkey(dns_peer_t *peer, dns_name_t **retval) {
434 REQUIRE(DNS_PEER_VALID(peer));
435 REQUIRE(retval != NULL);
437 if (peer->key != NULL) {
441 return (peer->key == NULL ? ISC_R_NOTFOUND : ISC_R_SUCCESS);
445 dns_peer_setkey(dns_peer_t *peer, dns_name_t **keyval) {
446 isc_boolean_t exists = ISC_FALSE;
448 if (peer->key != NULL) {
449 dns_name_free(peer->key, peer->mem);
450 isc_mem_put(peer->mem, peer->key, sizeof(dns_name_t));
457 return (exists ? ISC_R_EXISTS : ISC_R_SUCCESS);
461 dns_peer_setkeybycharp(dns_peer_t *peer, const char *keyval) {
463 dns_fixedname_t fname;
467 dns_fixedname_init(&fname);
468 isc_buffer_init(&b, keyval, strlen(keyval));
469 isc_buffer_add(&b, strlen(keyval));
470 result = dns_name_fromtext(dns_fixedname_name(&fname), &b,
471 dns_rootname, ISC_FALSE, NULL);
472 if (result != ISC_R_SUCCESS)
475 name = isc_mem_get(peer->mem, sizeof(dns_name_t));
477 return (ISC_R_NOMEMORY);
479 dns_name_init(name, NULL);
480 result = dns_name_dup(dns_fixedname_name(&fname), peer->mem, name);
481 if (result != ISC_R_SUCCESS) {
482 isc_mem_put(peer->mem, name, sizeof(dns_name_t));
486 result = dns_peer_setkey(peer, &name);
487 if (result != ISC_R_SUCCESS)
488 isc_mem_put(peer->mem, name, sizeof(dns_name_t));
494 dns_peer_settransfersource(dns_peer_t *peer,
495 const isc_sockaddr_t *transfer_source)
497 REQUIRE(DNS_PEER_VALID(peer));
499 if (peer->transfer_source != NULL) {
500 isc_mem_put(peer->mem, peer->transfer_source,
501 sizeof(*peer->transfer_source));
502 peer->transfer_source = NULL;
504 if (transfer_source != NULL) {
505 peer->transfer_source = isc_mem_get(peer->mem,
506 sizeof(*peer->transfer_source));
507 if (peer->transfer_source == NULL)
508 return (ISC_R_NOMEMORY);
510 *peer->transfer_source = *transfer_source;
512 return (ISC_R_SUCCESS);
516 dns_peer_gettransfersource(dns_peer_t *peer, isc_sockaddr_t *transfer_source) {
517 REQUIRE(DNS_PEER_VALID(peer));
518 REQUIRE(transfer_source != NULL);
520 if (peer->transfer_source == NULL)
521 return (ISC_R_NOTFOUND);
522 *transfer_source = *peer->transfer_source;
523 return (ISC_R_SUCCESS);