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.19.18.8 2006/02/28 03:10:48 marka Exp $ */
25 #include <isc/string.h>
27 #include <isc/sockaddr.h>
30 #include <dns/fixedname.h>
35 * Bit positions in the dns_peer_t structure flags field
38 #define SERVER_TRANSFER_FORMAT_BIT 1
39 #define TRANSFERS_BIT 2
40 #define PROVIDE_IXFR_BIT 3
41 #define REQUEST_IXFR_BIT 4
42 #define SUPPORT_EDNS_BIT 5
43 #define SERVER_UDPSIZE_BIT 6
44 #define SERVER_MAXUDP_BIT 7
47 peerlist_delete(dns_peerlist_t **list);
50 peer_delete(dns_peer_t **peer);
53 dns_peerlist_new(isc_mem_t *mem, dns_peerlist_t **list) {
56 REQUIRE(list != NULL);
58 l = isc_mem_get(mem, sizeof(*l));
60 return (ISC_R_NOMEMORY);
62 ISC_LIST_INIT(l->elements);
65 l->magic = DNS_PEERLIST_MAGIC;
69 return (ISC_R_SUCCESS);
73 dns_peerlist_attach(dns_peerlist_t *source, dns_peerlist_t **target) {
74 REQUIRE(DNS_PEERLIST_VALID(source));
75 REQUIRE(target != NULL);
76 REQUIRE(*target == NULL);
80 ENSURE(source->refs != 0xffffffffU);
86 dns_peerlist_detach(dns_peerlist_t **list) {
87 dns_peerlist_t *plist;
89 REQUIRE(list != NULL);
90 REQUIRE(*list != NULL);
91 REQUIRE(DNS_PEERLIST_VALID(*list));
96 REQUIRE(plist->refs > 0);
100 if (plist->refs == 0)
101 peerlist_delete(&plist);
105 peerlist_delete(dns_peerlist_t **list) {
107 dns_peer_t *server, *stmp;
109 REQUIRE(list != NULL);
110 REQUIRE(DNS_PEERLIST_VALID(*list));
114 REQUIRE(l->refs == 0);
116 server = ISC_LIST_HEAD(l->elements);
117 while (server != NULL) {
118 stmp = ISC_LIST_NEXT(server, next);
119 ISC_LIST_UNLINK(l->elements, server, next);
120 dns_peer_detach(&server);
125 isc_mem_put(l->mem, l, sizeof(*l));
131 dns_peerlist_addpeer(dns_peerlist_t *peers, dns_peer_t *peer) {
132 dns_peer_t *p = NULL;
134 dns_peer_attach(peer, &p);
137 * More specifics to front of list.
139 for (p = ISC_LIST_HEAD(peers->elements);
141 p = ISC_LIST_NEXT(p, next))
142 if (p->prefixlen < peer->prefixlen)
146 ISC_LIST_INSERTBEFORE(peers->elements, p, peer, next);
148 ISC_LIST_APPEND(peers->elements, peer, next);
153 dns_peerlist_peerbyaddr(dns_peerlist_t *servers,
154 isc_netaddr_t *addr, dns_peer_t **retval)
159 REQUIRE(retval != NULL);
160 REQUIRE(DNS_PEERLIST_VALID(servers));
162 server = ISC_LIST_HEAD(servers->elements);
163 while (server != NULL) {
164 if (isc_netaddr_eqprefix(addr, &server->address,
168 server = ISC_LIST_NEXT(server, next);
171 if (server != NULL) {
175 res = ISC_R_NOTFOUND;
184 dns_peerlist_currpeer(dns_peerlist_t *peers, dns_peer_t **retval) {
185 dns_peer_t *p = NULL;
187 p = ISC_LIST_TAIL(peers->elements);
189 dns_peer_attach(p, retval);
191 return (ISC_R_SUCCESS);
195 dns_peer_new(isc_mem_t *mem, isc_netaddr_t *addr, dns_peer_t **peerptr) {
196 unsigned int prefixlen = 0;
198 REQUIRE(peerptr != NULL);
199 switch(addr->family) {
210 return (dns_peer_newprefix(mem, addr, prefixlen, peerptr));
214 dns_peer_newprefix(isc_mem_t *mem, isc_netaddr_t *addr, unsigned int prefixlen,
215 dns_peer_t **peerptr)
219 REQUIRE(peerptr != NULL);
221 peer = isc_mem_get(mem, sizeof(*peer));
223 return (ISC_R_NOMEMORY);
225 peer->magic = DNS_PEER_MAGIC;
226 peer->address = *addr;
227 peer->prefixlen = prefixlen;
229 peer->bogus = ISC_FALSE;
230 peer->transfer_format = dns_one_answer;
232 peer->request_ixfr = ISC_FALSE;
233 peer->provide_ixfr = ISC_FALSE;
236 peer->transfer_source = NULL;
237 peer->notify_source = NULL;
238 peer->query_source = NULL;
240 memset(&peer->bitflags, 0x0, sizeof(peer->bitflags));
242 ISC_LINK_INIT(peer, next);
246 return (ISC_R_SUCCESS);
250 dns_peer_attach(dns_peer_t *source, dns_peer_t **target) {
251 REQUIRE(DNS_PEER_VALID(source));
252 REQUIRE(target != NULL);
253 REQUIRE(*target == NULL);
257 ENSURE(source->refs != 0xffffffffU);
263 dns_peer_detach(dns_peer_t **peer) {
266 REQUIRE(peer != NULL);
267 REQUIRE(*peer != NULL);
268 REQUIRE(DNS_PEER_VALID(*peer));
272 REQUIRE(p->refs > 0);
282 peer_delete(dns_peer_t **peer) {
286 REQUIRE(peer != NULL);
287 REQUIRE(DNS_PEER_VALID(*peer));
291 REQUIRE(p->refs == 0);
297 if (p->key != NULL) {
298 dns_name_free(p->key, mem);
299 isc_mem_put(mem, p->key, sizeof(dns_name_t));
302 if (p->transfer_source != NULL) {
303 isc_mem_put(mem, p->transfer_source,
304 sizeof(*p->transfer_source));
307 isc_mem_put(mem, p, sizeof(*p));
313 dns_peer_setbogus(dns_peer_t *peer, isc_boolean_t newval) {
314 isc_boolean_t existed;
316 REQUIRE(DNS_PEER_VALID(peer));
318 existed = DNS_BIT_CHECK(BOGUS_BIT, &peer->bitflags);
320 peer->bogus = newval;
321 DNS_BIT_SET(BOGUS_BIT, &peer->bitflags);
323 return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS);
327 dns_peer_getbogus(dns_peer_t *peer, isc_boolean_t *retval) {
328 REQUIRE(DNS_PEER_VALID(peer));
329 REQUIRE(retval != NULL);
331 if (DNS_BIT_CHECK(BOGUS_BIT, &peer->bitflags)) {
332 *retval = peer->bogus;
333 return (ISC_R_SUCCESS);
335 return (ISC_R_NOTFOUND);
340 dns_peer_setprovideixfr(dns_peer_t *peer, isc_boolean_t newval) {
341 isc_boolean_t existed;
343 REQUIRE(DNS_PEER_VALID(peer));
345 existed = DNS_BIT_CHECK(PROVIDE_IXFR_BIT, &peer->bitflags);
347 peer->provide_ixfr = newval;
348 DNS_BIT_SET(PROVIDE_IXFR_BIT, &peer->bitflags);
350 return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS);
354 dns_peer_getprovideixfr(dns_peer_t *peer, isc_boolean_t *retval) {
355 REQUIRE(DNS_PEER_VALID(peer));
356 REQUIRE(retval != NULL);
358 if (DNS_BIT_CHECK(PROVIDE_IXFR_BIT, &peer->bitflags)) {
359 *retval = peer->provide_ixfr;
360 return (ISC_R_SUCCESS);
362 return (ISC_R_NOTFOUND);
367 dns_peer_setrequestixfr(dns_peer_t *peer, isc_boolean_t newval) {
368 isc_boolean_t existed;
370 REQUIRE(DNS_PEER_VALID(peer));
372 existed = DNS_BIT_CHECK(REQUEST_IXFR_BIT, &peer->bitflags);
374 peer->request_ixfr = newval;
375 DNS_BIT_SET(REQUEST_IXFR_BIT, &peer->bitflags);
377 return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS);
381 dns_peer_getrequestixfr(dns_peer_t *peer, isc_boolean_t *retval) {
382 REQUIRE(DNS_PEER_VALID(peer));
383 REQUIRE(retval != NULL);
385 if (DNS_BIT_CHECK(REQUEST_IXFR_BIT, &peer->bitflags)) {
386 *retval = peer->request_ixfr;
387 return (ISC_R_SUCCESS);
389 return (ISC_R_NOTFOUND);
393 dns_peer_setsupportedns(dns_peer_t *peer, isc_boolean_t newval) {
394 isc_boolean_t existed;
396 REQUIRE(DNS_PEER_VALID(peer));
398 existed = DNS_BIT_CHECK(SUPPORT_EDNS_BIT, &peer->bitflags);
400 peer->support_edns = newval;
401 DNS_BIT_SET(SUPPORT_EDNS_BIT, &peer->bitflags);
403 return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS);
407 dns_peer_getsupportedns(dns_peer_t *peer, isc_boolean_t *retval) {
408 REQUIRE(DNS_PEER_VALID(peer));
409 REQUIRE(retval != NULL);
411 if (DNS_BIT_CHECK(SUPPORT_EDNS_BIT, &peer->bitflags)) {
412 *retval = peer->support_edns;
413 return (ISC_R_SUCCESS);
415 return (ISC_R_NOTFOUND);
419 dns_peer_settransfers(dns_peer_t *peer, isc_uint32_t newval) {
420 isc_boolean_t existed;
422 REQUIRE(DNS_PEER_VALID(peer));
424 existed = DNS_BIT_CHECK(TRANSFERS_BIT, &peer->bitflags);
426 peer->transfers = newval;
427 DNS_BIT_SET(TRANSFERS_BIT, &peer->bitflags);
429 return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS);
433 dns_peer_gettransfers(dns_peer_t *peer, isc_uint32_t *retval) {
434 REQUIRE(DNS_PEER_VALID(peer));
435 REQUIRE(retval != NULL);
437 if (DNS_BIT_CHECK(TRANSFERS_BIT, &peer->bitflags)) {
438 *retval = peer->transfers;
439 return (ISC_R_SUCCESS);
441 return (ISC_R_NOTFOUND);
446 dns_peer_settransferformat(dns_peer_t *peer, dns_transfer_format_t newval) {
447 isc_boolean_t existed;
449 REQUIRE(DNS_PEER_VALID(peer));
451 existed = DNS_BIT_CHECK(SERVER_TRANSFER_FORMAT_BIT,
454 peer->transfer_format = newval;
455 DNS_BIT_SET(SERVER_TRANSFER_FORMAT_BIT, &peer->bitflags);
457 return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS);
461 dns_peer_gettransferformat(dns_peer_t *peer, dns_transfer_format_t *retval) {
462 REQUIRE(DNS_PEER_VALID(peer));
463 REQUIRE(retval != NULL);
465 if (DNS_BIT_CHECK(SERVER_TRANSFER_FORMAT_BIT, &peer->bitflags)) {
466 *retval = peer->transfer_format;
467 return (ISC_R_SUCCESS);
469 return (ISC_R_NOTFOUND);
474 dns_peer_getkey(dns_peer_t *peer, dns_name_t **retval) {
475 REQUIRE(DNS_PEER_VALID(peer));
476 REQUIRE(retval != NULL);
478 if (peer->key != NULL) {
482 return (peer->key == NULL ? ISC_R_NOTFOUND : ISC_R_SUCCESS);
486 dns_peer_setkey(dns_peer_t *peer, dns_name_t **keyval) {
487 isc_boolean_t exists = ISC_FALSE;
489 if (peer->key != NULL) {
490 dns_name_free(peer->key, peer->mem);
491 isc_mem_put(peer->mem, peer->key, sizeof(dns_name_t));
498 return (exists ? ISC_R_EXISTS : ISC_R_SUCCESS);
502 dns_peer_setkeybycharp(dns_peer_t *peer, const char *keyval) {
504 dns_fixedname_t fname;
508 dns_fixedname_init(&fname);
509 isc_buffer_init(&b, keyval, strlen(keyval));
510 isc_buffer_add(&b, strlen(keyval));
511 result = dns_name_fromtext(dns_fixedname_name(&fname), &b,
512 dns_rootname, ISC_FALSE, NULL);
513 if (result != ISC_R_SUCCESS)
516 name = isc_mem_get(peer->mem, sizeof(dns_name_t));
518 return (ISC_R_NOMEMORY);
520 dns_name_init(name, NULL);
521 result = dns_name_dup(dns_fixedname_name(&fname), peer->mem, name);
522 if (result != ISC_R_SUCCESS) {
523 isc_mem_put(peer->mem, name, sizeof(dns_name_t));
527 result = dns_peer_setkey(peer, &name);
528 if (result != ISC_R_SUCCESS)
529 isc_mem_put(peer->mem, name, sizeof(dns_name_t));
535 dns_peer_settransfersource(dns_peer_t *peer,
536 const isc_sockaddr_t *transfer_source)
538 REQUIRE(DNS_PEER_VALID(peer));
540 if (peer->transfer_source != NULL) {
541 isc_mem_put(peer->mem, peer->transfer_source,
542 sizeof(*peer->transfer_source));
543 peer->transfer_source = NULL;
545 if (transfer_source != NULL) {
546 peer->transfer_source = isc_mem_get(peer->mem,
547 sizeof(*peer->transfer_source));
548 if (peer->transfer_source == NULL)
549 return (ISC_R_NOMEMORY);
551 *peer->transfer_source = *transfer_source;
553 return (ISC_R_SUCCESS);
557 dns_peer_gettransfersource(dns_peer_t *peer, isc_sockaddr_t *transfer_source) {
558 REQUIRE(DNS_PEER_VALID(peer));
559 REQUIRE(transfer_source != NULL);
561 if (peer->transfer_source == NULL)
562 return (ISC_R_NOTFOUND);
563 *transfer_source = *peer->transfer_source;
564 return (ISC_R_SUCCESS);
568 dns_peer_setnotifysource(dns_peer_t *peer,
569 const isc_sockaddr_t *notify_source)
571 REQUIRE(DNS_PEER_VALID(peer));
573 if (peer->notify_source != NULL) {
574 isc_mem_put(peer->mem, peer->notify_source,
575 sizeof(*peer->notify_source));
576 peer->notify_source = NULL;
578 if (notify_source != NULL) {
579 peer->notify_source = isc_mem_get(peer->mem,
580 sizeof(*peer->notify_source));
581 if (peer->notify_source == NULL)
582 return (ISC_R_NOMEMORY);
584 *peer->notify_source = *notify_source;
586 return (ISC_R_SUCCESS);
590 dns_peer_getnotifysource(dns_peer_t *peer, isc_sockaddr_t *notify_source) {
591 REQUIRE(DNS_PEER_VALID(peer));
592 REQUIRE(notify_source != NULL);
594 if (peer->notify_source == NULL)
595 return (ISC_R_NOTFOUND);
596 *notify_source = *peer->notify_source;
597 return (ISC_R_SUCCESS);
601 dns_peer_setquerysource(dns_peer_t *peer, const isc_sockaddr_t *query_source) {
602 REQUIRE(DNS_PEER_VALID(peer));
604 if (peer->query_source != NULL) {
605 isc_mem_put(peer->mem, peer->query_source,
606 sizeof(*peer->query_source));
607 peer->query_source = NULL;
609 if (query_source != NULL) {
610 peer->query_source = isc_mem_get(peer->mem,
611 sizeof(*peer->query_source));
612 if (peer->query_source == NULL)
613 return (ISC_R_NOMEMORY);
615 *peer->query_source = *query_source;
617 return (ISC_R_SUCCESS);
621 dns_peer_getquerysource(dns_peer_t *peer, isc_sockaddr_t *query_source) {
622 REQUIRE(DNS_PEER_VALID(peer));
623 REQUIRE(query_source != NULL);
625 if (peer->query_source == NULL)
626 return (ISC_R_NOTFOUND);
627 *query_source = *peer->query_source;
628 return (ISC_R_SUCCESS);
632 dns_peer_setudpsize(dns_peer_t *peer, isc_uint16_t udpsize) {
633 isc_boolean_t existed;
635 REQUIRE(DNS_PEER_VALID(peer));
637 existed = DNS_BIT_CHECK(SERVER_UDPSIZE_BIT, &peer->bitflags);
639 peer->udpsize = udpsize;
640 DNS_BIT_SET(SERVER_UDPSIZE_BIT, &peer->bitflags);
642 return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS);
646 dns_peer_getudpsize(dns_peer_t *peer, isc_uint16_t *udpsize) {
648 REQUIRE(DNS_PEER_VALID(peer));
649 REQUIRE(udpsize != NULL);
651 if (DNS_BIT_CHECK(SERVER_UDPSIZE_BIT, &peer->bitflags)) {
652 *udpsize = peer->udpsize;
653 return (ISC_R_SUCCESS);
655 return (ISC_R_NOTFOUND);
660 dns_peer_setmaxudp(dns_peer_t *peer, isc_uint16_t maxudp) {
661 isc_boolean_t existed;
663 REQUIRE(DNS_PEER_VALID(peer));
665 existed = DNS_BIT_CHECK(SERVER_MAXUDP_BIT, &peer->bitflags);
667 peer->maxudp = maxudp;
668 DNS_BIT_SET(SERVER_MAXUDP_BIT, &peer->bitflags);
670 return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS);
674 dns_peer_getmaxudp(dns_peer_t *peer, isc_uint16_t *maxudp) {
676 REQUIRE(DNS_PEER_VALID(peer));
677 REQUIRE(maxudp != NULL);
679 if (DNS_BIT_CHECK(SERVER_MAXUDP_BIT, &peer->bitflags)) {
680 *maxudp = peer->maxudp;
681 return (ISC_R_SUCCESS);
683 return (ISC_R_NOTFOUND);