2 * Copyright (C) 2004 Internet Systems Consortium, Inc. ("ISC")
3 * Copyright (C) 2000, 2001 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.2 2004/03/09 06:11:04 marka Exp $ */
23 #include <isc/string.h>
27 #include <dns/fixedname.h>
32 * Bit positions in the dns_peer_t structure flags field
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
42 dns_peerlist_delete(dns_peerlist_t **list);
45 dns_peer_delete(dns_peer_t **peer);
48 dns_peerlist_new(isc_mem_t *mem, dns_peerlist_t **list) {
51 REQUIRE(list != NULL);
53 l = isc_mem_get(mem, sizeof *l);
55 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);
97 if (plist->refs == 0) {
98 dns_peerlist_delete(&plist);
103 dns_peerlist_delete(dns_peerlist_t **list) {
105 dns_peer_t *server, *stmp;
108 REQUIRE(list != NULL);
109 REQUIRE(DNS_PEERLIST_VALID(*list));
113 REQUIRE(l->refs == 0);
115 server = ISC_LIST_HEAD(l->elements);
116 while (server != NULL) {
117 stmp = ISC_LIST_NEXT(server, next);
118 ISC_LIST_UNLINK(l->elements, server, next);
119 r = dns_peer_detach(&server);
120 if (r != ISC_R_SUCCESS) {
128 isc_mem_put(l->mem, l, sizeof *l);
132 return (ISC_R_SUCCESS);
136 dns_peerlist_addpeer(dns_peerlist_t *peers, dns_peer_t *peer) {
137 dns_peer_t *p = NULL;
139 dns_peer_attach(peer, &p);
141 ISC_LIST_APPEND(peers->elements, peer, next);
145 dns_peerlist_peerbyaddr(dns_peerlist_t *servers,
146 isc_netaddr_t *addr, dns_peer_t **retval)
151 REQUIRE(retval != NULL);
152 REQUIRE(DNS_PEERLIST_VALID(servers));
154 server = ISC_LIST_HEAD(servers->elements);
155 while (server != NULL) {
156 if (isc_netaddr_equal(addr, &server->address)) {
160 server = ISC_LIST_NEXT(server, next);
163 if (server != NULL) {
167 res = ISC_R_NOTFOUND;
176 dns_peerlist_currpeer(dns_peerlist_t *peers, dns_peer_t **retval) {
177 dns_peer_t *p = NULL;
179 p = ISC_LIST_TAIL(peers->elements);
181 dns_peer_attach(p, retval);
183 return (ISC_R_SUCCESS);
187 dns_peer_new(isc_mem_t *mem, isc_netaddr_t *addr, dns_peer_t **peerptr) {
190 REQUIRE(peerptr != NULL);
192 peer = isc_mem_get(mem, sizeof *peer);
194 return (ISC_R_NOMEMORY);
197 peer->magic = DNS_PEER_MAGIC;
198 peer->address = *addr;
200 peer->bogus = ISC_FALSE;
201 peer->transfer_format = dns_one_answer;
203 peer->request_ixfr = ISC_FALSE;
204 peer->provide_ixfr = ISC_FALSE;
208 memset(&peer->bitflags, 0x0, sizeof peer->bitflags);
210 ISC_LINK_INIT(peer, next);
214 return (ISC_R_SUCCESS);
218 dns_peer_attach(dns_peer_t *source, dns_peer_t **target) {
219 REQUIRE(DNS_PEER_VALID(source));
220 REQUIRE(target != NULL);
221 REQUIRE(*target == NULL);
225 ENSURE(source->refs != 0xffffffffU);
229 return (ISC_R_SUCCESS);
233 dns_peer_detach(dns_peer_t **peer) {
236 REQUIRE(peer != NULL);
237 REQUIRE(*peer != NULL);
238 REQUIRE(DNS_PEER_VALID(*peer));
242 REQUIRE(p->refs > 0);
251 return (ISC_R_SUCCESS);
255 dns_peer_delete(dns_peer_t **peer) {
259 REQUIRE(peer != NULL);
260 REQUIRE(DNS_PEER_VALID(*peer));
264 REQUIRE(p->refs == 0);
270 if (p->key != NULL) {
271 dns_name_free(p->key, mem);
272 isc_mem_put(mem, p->key, sizeof(dns_name_t));
275 isc_mem_put(mem, p, sizeof *p);
279 return (ISC_R_SUCCESS);
283 dns_peer_setbogus(dns_peer_t *peer, isc_boolean_t newval) {
284 isc_boolean_t existed;
286 REQUIRE(DNS_PEER_VALID(peer));
288 existed = DNS_BIT_CHECK(BOGUS_BIT, &peer->bitflags);
290 peer->bogus = newval;
291 DNS_BIT_SET(BOGUS_BIT, &peer->bitflags);
293 return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS);
297 dns_peer_getbogus(dns_peer_t *peer, isc_boolean_t *retval) {
298 REQUIRE(DNS_PEER_VALID(peer));
299 REQUIRE(retval != NULL);
301 if (DNS_BIT_CHECK(BOGUS_BIT, &peer->bitflags)) {
302 *retval = peer->bogus;
303 return (ISC_R_SUCCESS);
305 return (ISC_R_NOTFOUND);
310 dns_peer_setprovideixfr(dns_peer_t *peer, isc_boolean_t newval) {
311 isc_boolean_t existed;
313 REQUIRE(DNS_PEER_VALID(peer));
315 existed = DNS_BIT_CHECK(PROVIDE_IXFR_BIT, &peer->bitflags);
317 peer->provide_ixfr = newval;
318 DNS_BIT_SET(PROVIDE_IXFR_BIT, &peer->bitflags);
320 return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS);
324 dns_peer_getprovideixfr(dns_peer_t *peer, isc_boolean_t *retval) {
325 REQUIRE(DNS_PEER_VALID(peer));
326 REQUIRE(retval != NULL);
328 if (DNS_BIT_CHECK(PROVIDE_IXFR_BIT, &peer->bitflags)) {
329 *retval = peer->provide_ixfr;
330 return (ISC_R_SUCCESS);
332 return (ISC_R_NOTFOUND);
337 dns_peer_setrequestixfr(dns_peer_t *peer, isc_boolean_t newval) {
338 isc_boolean_t existed;
340 REQUIRE(DNS_PEER_VALID(peer));
342 existed = DNS_BIT_CHECK(REQUEST_IXFR_BIT, &peer->bitflags);
344 peer->request_ixfr = newval;
345 DNS_BIT_SET(REQUEST_IXFR_BIT, &peer->bitflags);
347 return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS);
351 dns_peer_getrequestixfr(dns_peer_t *peer, isc_boolean_t *retval) {
352 REQUIRE(DNS_PEER_VALID(peer));
353 REQUIRE(retval != NULL);
355 if (DNS_BIT_CHECK(REQUEST_IXFR_BIT, &peer->bitflags)) {
356 *retval = peer->request_ixfr;
357 return (ISC_R_SUCCESS);
359 return (ISC_R_NOTFOUND);
363 dns_peer_setsupportedns(dns_peer_t *peer, isc_boolean_t newval) {
364 isc_boolean_t existed;
366 REQUIRE(DNS_PEER_VALID(peer));
368 existed = DNS_BIT_CHECK(SUPPORT_EDNS_BIT, &peer->bitflags);
370 peer->support_edns = newval;
371 DNS_BIT_SET(SUPPORT_EDNS_BIT, &peer->bitflags);
373 return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS);
377 dns_peer_getsupportedns(dns_peer_t *peer, isc_boolean_t *retval) {
378 REQUIRE(DNS_PEER_VALID(peer));
379 REQUIRE(retval != NULL);
381 if (DNS_BIT_CHECK(SUPPORT_EDNS_BIT, &peer->bitflags)) {
382 *retval = peer->support_edns;
383 return (ISC_R_SUCCESS);
385 return (ISC_R_NOTFOUND);
389 dns_peer_settransfers(dns_peer_t *peer, isc_uint32_t newval) {
390 isc_boolean_t existed;
392 REQUIRE(DNS_PEER_VALID(peer));
394 existed = DNS_BIT_CHECK(TRANSFERS_BIT, &peer->bitflags);
396 peer->transfers = newval;
397 DNS_BIT_SET(TRANSFERS_BIT, &peer->bitflags);
399 return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS);
403 dns_peer_gettransfers(dns_peer_t *peer, isc_uint32_t *retval) {
404 REQUIRE(DNS_PEER_VALID(peer));
405 REQUIRE(retval != NULL);
407 if (DNS_BIT_CHECK(TRANSFERS_BIT, &peer->bitflags)) {
408 *retval = peer->transfers;
409 return (ISC_R_SUCCESS);
411 return (ISC_R_NOTFOUND);
416 dns_peer_settransferformat(dns_peer_t *peer, dns_transfer_format_t newval) {
417 isc_boolean_t existed;
419 REQUIRE(DNS_PEER_VALID(peer));
421 existed = DNS_BIT_CHECK(SERVER_TRANSFER_FORMAT_BIT,
424 peer->transfer_format = newval;
425 DNS_BIT_SET(SERVER_TRANSFER_FORMAT_BIT, &peer->bitflags);
427 return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS);
431 dns_peer_gettransferformat(dns_peer_t *peer, dns_transfer_format_t *retval) {
432 REQUIRE(DNS_PEER_VALID(peer));
433 REQUIRE(retval != NULL);
435 if (DNS_BIT_CHECK(SERVER_TRANSFER_FORMAT_BIT, &peer->bitflags)) {
436 *retval = peer->transfer_format;
437 return (ISC_R_SUCCESS);
439 return (ISC_R_NOTFOUND);
444 dns_peer_getkey(dns_peer_t *peer, dns_name_t **retval) {
445 REQUIRE(DNS_PEER_VALID(peer));
446 REQUIRE(retval != NULL);
448 if (peer->key != NULL) {
452 return (peer->key == NULL ? ISC_R_NOTFOUND : ISC_R_SUCCESS);
456 dns_peer_setkey(dns_peer_t *peer, dns_name_t **keyval) {
457 isc_boolean_t exists = ISC_FALSE;
459 if (peer->key != NULL) {
460 dns_name_free(peer->key, peer->mem);
461 isc_mem_put(peer->mem, peer->key, sizeof(dns_name_t));
468 return (exists ? ISC_R_EXISTS : ISC_R_SUCCESS);
472 dns_peer_setkeybycharp(dns_peer_t *peer, const char *keyval) {
474 dns_fixedname_t fname;
478 dns_fixedname_init(&fname);
479 isc_buffer_init(&b, keyval, strlen(keyval));
480 isc_buffer_add(&b, strlen(keyval));
481 result = dns_name_fromtext(dns_fixedname_name(&fname), &b,
482 dns_rootname, ISC_FALSE, NULL);
483 if (result != ISC_R_SUCCESS)
486 name = isc_mem_get(peer->mem, sizeof(dns_name_t));
488 return (ISC_R_NOMEMORY);
490 dns_name_init(name, NULL);
491 result = dns_name_dup(dns_fixedname_name(&fname), peer->mem, name);
492 if (result != ISC_R_SUCCESS) {
493 isc_mem_put(peer->mem, name, sizeof(dns_name_t));
497 result = dns_peer_setkey(peer, &name);
498 if (result != ISC_R_SUCCESS)
499 isc_mem_put(peer->mem, name, sizeof(dns_name_t));