contrib/bind-9.3/lib/dns/peer.c

   1 /*
   2  * Copyright (C) 2004, 2006  Internet Systems Consortium, Inc. ("ISC")
   3  * Copyright (C) 2000, 2001, 2003  Internet Software Consortium.
   4  *
   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.
   8  *
   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.
  16  */
  17
  18 /* $Id: peer.c,v 1.14.2.1.10.6 2006/03/02 00:37:20 marka Exp $ */
  19
  20 #include <config.h>
  21
  22 #include <isc/mem.h>
  23 #include <isc/string.h>
  24 #include <isc/util.h>
  25 #include <isc/sockaddr.h>
  26
  27 #include <dns/bit.h>
  28 #include <dns/fixedname.h>
  29 #include <dns/name.h>
  30 #include <dns/peer.h>
  31
  32 /*
  33  * Bit positions in the dns_peer_t structure flags field
  34  */
  35 #define BOGUS_BIT                       0
  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
  41
  42 static void
  43 peerlist_delete(dns_peerlist_t **list);
  44
  45 static void
  46 peer_delete(dns_peer_t **peer);
  47
  48 isc_result_t
  49 dns_peerlist_new(isc_mem_t *mem, dns_peerlist_t **list) {
  50         dns_peerlist_t *l;
  51
  52         REQUIRE(list != NULL);
  53
  54         l = isc_mem_get(mem, sizeof(*l));
  55         if (l == NULL)
  56                 return (ISC_R_NOMEMORY);
  57
  58         ISC_LIST_INIT(l->elements);
  59         l->mem = mem;
  60         l->refs = 1;
  61         l->magic = DNS_PEERLIST_MAGIC;
  62
  63         *list = l;
  64
  65         return (ISC_R_SUCCESS);
  66 }
  67
  68
  69 void
  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);
  74
  75         source->refs++;
  76
  77         ENSURE(source->refs != 0xffffffffU);
  78
  79         *target = source;
  80 }
  81
  82 void
  83 dns_peerlist_detach(dns_peerlist_t **list) {
  84         dns_peerlist_t *plist;
  85
  86         REQUIRE(list != NULL);
  87         REQUIRE(*list != NULL);
  88         REQUIRE(DNS_PEERLIST_VALID(*list));
  89
  90         plist = *list;
  91         *list = NULL;
  92
  93         REQUIRE(plist->refs > 0);
  94
  95         plist->refs--;
  96
  97         if (plist->refs == 0)
  98                 peerlist_delete(&plist);
  99 }
 100
 101 static void
 102 peerlist_delete(dns_peerlist_t **list) {
 103         dns_peerlist_t *l;
 104         dns_peer_t *server, *stmp;
 105
 106         REQUIRE(list != NULL);
 107         REQUIRE(DNS_PEERLIST_VALID(*list));
 108
 109         l = *list;
 110
 111         REQUIRE(l->refs == 0);
 112
 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);
 118                 server = stmp;
 119         }
 120
 121         l->magic = 0;
 122         isc_mem_put(l->mem, l, sizeof(*l));
 123
 124         *list = NULL;
 125 }
 126
 127 void
 128 dns_peerlist_addpeer(dns_peerlist_t *peers, dns_peer_t *peer) {
 129         dns_peer_t *p = NULL;
 130
 131         dns_peer_attach(peer, &p);
 132
 133         ISC_LIST_APPEND(peers->elements, peer, next);
 134 }
 135
 136 isc_result_t
 137 dns_peerlist_peerbyaddr(dns_peerlist_t *servers,
 138                         isc_netaddr_t *addr, dns_peer_t **retval)
 139 {
 140         dns_peer_t *server;
 141         isc_result_t res;
 142
 143         REQUIRE(retval != NULL);
 144         REQUIRE(DNS_PEERLIST_VALID(servers));
 145
 146         server = ISC_LIST_HEAD(servers->elements);
 147         while (server != NULL) {
 148                 if (isc_netaddr_equal(addr, &server->address))
 149                         break;
 150
 151                 server = ISC_LIST_NEXT(server, next);
 152         }
 153
 154         if (server != NULL) {
 155                 *retval = server;
 156                 res = ISC_R_SUCCESS;
 157         } else {
 158                 res = ISC_R_NOTFOUND;
 159         }
 160
 161         return (res);
 162 }
 163
 164
 165
 166 isc_result_t
 167 dns_peerlist_currpeer(dns_peerlist_t *peers, dns_peer_t **retval) {
 168         dns_peer_t *p = NULL;
 169
 170         p = ISC_LIST_TAIL(peers->elements);
 171
 172         dns_peer_attach(p, retval);
 173
 174         return (ISC_R_SUCCESS);
 175 }
 176
 177 isc_result_t
 178 dns_peer_new(isc_mem_t *mem, isc_netaddr_t *addr, dns_peer_t **peerptr) {
 179         dns_peer_t *peer;
 180
 181         REQUIRE(peerptr != NULL);
 182
 183         peer = isc_mem_get(mem, sizeof(*peer));
 184         if (peer == NULL)
 185                 return (ISC_R_NOMEMORY);
 186
 187         peer->magic = DNS_PEER_MAGIC;
 188         peer->address = *addr;
 189         peer->mem = mem;
 190         peer->bogus = ISC_FALSE;
 191         peer->transfer_format = dns_one_answer;
 192         peer->transfers = 0;
 193         peer->request_ixfr = ISC_FALSE;
 194         peer->provide_ixfr = ISC_FALSE;
 195         peer->key = NULL;
 196         peer->refs = 1;
 197         peer->transfer_source = NULL;
 198
 199         memset(&peer->bitflags, 0x0, sizeof(peer->bitflags));
 200
 201         ISC_LINK_INIT(peer, next);
 202
 203         *peerptr = peer;
 204
 205         return (ISC_R_SUCCESS);
 206 }
 207
 208 void
 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);
 213
 214         source->refs++;
 215
 216         ENSURE(source->refs != 0xffffffffU);
 217
 218         *target = source;
 219 }
 220
 221 void
 222 dns_peer_detach(dns_peer_t **peer) {
 223         dns_peer_t *p;
 224
 225         REQUIRE(peer != NULL);
 226         REQUIRE(*peer != NULL);
 227         REQUIRE(DNS_PEER_VALID(*peer));
 228
 229         p = *peer;
 230
 231         REQUIRE(p->refs > 0);
 232
 233         *peer = NULL;
 234         p->refs--;
 235
 236         if (p->refs == 0)
 237                 peer_delete(&p);
 238 }
 239
 240 static void
 241 peer_delete(dns_peer_t **peer) {
 242         dns_peer_t *p;
 243         isc_mem_t *mem;
 244
 245         REQUIRE(peer != NULL);
 246         REQUIRE(DNS_PEER_VALID(*peer));
 247
 248         p = *peer;
 249
 250         REQUIRE(p->refs == 0);
 251
 252         mem = p->mem;
 253         p->mem = NULL;
 254         p->magic = 0;
 255
 256         if (p->key != NULL) {
 257                 dns_name_free(p->key, mem);
 258                 isc_mem_put(mem, p->key, sizeof(dns_name_t));
 259         }
 260
 261         if (p->transfer_source != NULL) {
 262                 isc_mem_put(mem, p->transfer_source,
 263                             sizeof(*p->transfer_source));
 264         }
 265
 266         isc_mem_put(mem, p, sizeof(*p));
 267
 268         *peer = NULL;
 269 }
 270
 271 isc_result_t
 272 dns_peer_setbogus(dns_peer_t *peer, isc_boolean_t newval) {
 273         isc_boolean_t existed;
 274
 275         REQUIRE(DNS_PEER_VALID(peer));
 276
 277         existed = DNS_BIT_CHECK(BOGUS_BIT, &peer->bitflags);
 278
 279         peer->bogus = newval;
 280         DNS_BIT_SET(BOGUS_BIT, &peer->bitflags);
 281
 282         return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS);
 283 }
 284
 285 isc_result_t
 286 dns_peer_getbogus(dns_peer_t *peer, isc_boolean_t *retval) {
 287         REQUIRE(DNS_PEER_VALID(peer));
 288         REQUIRE(retval != NULL);
 289
 290         if (DNS_BIT_CHECK(BOGUS_BIT, &peer->bitflags)) {
 291                 *retval = peer->bogus;
 292                 return (ISC_R_SUCCESS);
 293         } else
 294                 return (ISC_R_NOTFOUND);
 295 }
 296
 297
 298 isc_result_t
 299 dns_peer_setprovideixfr(dns_peer_t *peer, isc_boolean_t newval) {
 300         isc_boolean_t existed;
 301
 302         REQUIRE(DNS_PEER_VALID(peer));
 303
 304         existed = DNS_BIT_CHECK(PROVIDE_IXFR_BIT, &peer->bitflags);
 305
 306         peer->provide_ixfr = newval;
 307         DNS_BIT_SET(PROVIDE_IXFR_BIT, &peer->bitflags);
 308
 309         return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS);
 310 }
 311
 312 isc_result_t
 313 dns_peer_getprovideixfr(dns_peer_t *peer, isc_boolean_t *retval) {
 314         REQUIRE(DNS_PEER_VALID(peer));
 315         REQUIRE(retval != NULL);
 316
 317         if (DNS_BIT_CHECK(PROVIDE_IXFR_BIT, &peer->bitflags)) {
 318                 *retval = peer->provide_ixfr;
 319                 return (ISC_R_SUCCESS);
 320         } else {
 321                 return (ISC_R_NOTFOUND);
 322         }
 323 }
 324
 325 isc_result_t
 326 dns_peer_setrequestixfr(dns_peer_t *peer, isc_boolean_t newval) {
 327         isc_boolean_t existed;
 328
 329         REQUIRE(DNS_PEER_VALID(peer));
 330
 331         existed = DNS_BIT_CHECK(REQUEST_IXFR_BIT, &peer->bitflags);
 332
 333         peer->request_ixfr = newval;
 334         DNS_BIT_SET(REQUEST_IXFR_BIT, &peer->bitflags);
 335
 336         return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS);
 337 }
 338
 339 isc_result_t
 340 dns_peer_getrequestixfr(dns_peer_t *peer, isc_boolean_t *retval) {
 341         REQUIRE(DNS_PEER_VALID(peer));
 342         REQUIRE(retval != NULL);
 343
 344         if (DNS_BIT_CHECK(REQUEST_IXFR_BIT, &peer->bitflags)) {
 345                 *retval = peer->request_ixfr;
 346                 return (ISC_R_SUCCESS);
 347         } else
 348                 return (ISC_R_NOTFOUND);
 349 }
 350
 351 isc_result_t
 352 dns_peer_setsupportedns(dns_peer_t *peer, isc_boolean_t newval) {
 353         isc_boolean_t existed;
 354
 355         REQUIRE(DNS_PEER_VALID(peer));
 356
 357         existed = DNS_BIT_CHECK(SUPPORT_EDNS_BIT, &peer->bitflags);
 358
 359         peer->support_edns = newval;
 360         DNS_BIT_SET(SUPPORT_EDNS_BIT, &peer->bitflags);
 361
 362         return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS);
 363 }
 364
 365 isc_result_t
 366 dns_peer_getsupportedns(dns_peer_t *peer, isc_boolean_t *retval) {
 367         REQUIRE(DNS_PEER_VALID(peer));
 368         REQUIRE(retval != NULL);
 369
 370         if (DNS_BIT_CHECK(SUPPORT_EDNS_BIT, &peer->bitflags)) {
 371                 *retval = peer->support_edns;
 372                 return (ISC_R_SUCCESS);
 373         } else
 374                 return (ISC_R_NOTFOUND);
 375 }
 376
 377 isc_result_t
 378 dns_peer_settransfers(dns_peer_t *peer, isc_uint32_t newval) {
 379         isc_boolean_t existed;
 380
 381         REQUIRE(DNS_PEER_VALID(peer));
 382
 383         existed = DNS_BIT_CHECK(TRANSFERS_BIT, &peer->bitflags);
 384
 385         peer->transfers = newval;
 386         DNS_BIT_SET(TRANSFERS_BIT, &peer->bitflags);
 387
 388         return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS);
 389 }
 390
 391 isc_result_t
 392 dns_peer_gettransfers(dns_peer_t *peer, isc_uint32_t *retval) {
 393         REQUIRE(DNS_PEER_VALID(peer));
 394         REQUIRE(retval != NULL);
 395
 396         if (DNS_BIT_CHECK(TRANSFERS_BIT, &peer->bitflags)) {
 397                 *retval = peer->transfers;
 398                 return (ISC_R_SUCCESS);
 399         } else {
 400                 return (ISC_R_NOTFOUND);
 401         }
 402 }
 403
 404 isc_result_t
 405 dns_peer_settransferformat(dns_peer_t *peer, dns_transfer_format_t newval) {
 406         isc_boolean_t existed;
 407
 408         REQUIRE(DNS_PEER_VALID(peer));
 409
 410         existed = DNS_BIT_CHECK(SERVER_TRANSFER_FORMAT_BIT,
 411                                  &peer->bitflags);
 412
 413         peer->transfer_format = newval;
 414         DNS_BIT_SET(SERVER_TRANSFER_FORMAT_BIT, &peer->bitflags);
 415
 416         return (existed ? ISC_R_EXISTS : ISC_R_SUCCESS);
 417 }
 418
 419 isc_result_t
 420 dns_peer_gettransferformat(dns_peer_t *peer, dns_transfer_format_t *retval) {
 421         REQUIRE(DNS_PEER_VALID(peer));
 422         REQUIRE(retval != NULL);
 423
 424         if (DNS_BIT_CHECK(SERVER_TRANSFER_FORMAT_BIT, &peer->bitflags)) {
 425                 *retval = peer->transfer_format;
 426                 return (ISC_R_SUCCESS);
 427         } else {
 428                 return (ISC_R_NOTFOUND);
 429         }
 430 }
 431
 432 isc_result_t
 433 dns_peer_getkey(dns_peer_t *peer, dns_name_t **retval) {
 434         REQUIRE(DNS_PEER_VALID(peer));
 435         REQUIRE(retval != NULL);
 436
 437         if (peer->key != NULL) {
 438                 *retval = peer->key;
 439         }
 440
 441         return (peer->key == NULL ? ISC_R_NOTFOUND : ISC_R_SUCCESS);
 442 }
 443
 444 isc_result_t
 445 dns_peer_setkey(dns_peer_t *peer, dns_name_t **keyval) {
 446         isc_boolean_t exists = ISC_FALSE;
 447
 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));
 451                 exists = ISC_TRUE;
 452         }
 453
 454         peer->key = *keyval;
 455         *keyval = NULL;
 456
 457         return (exists ? ISC_R_EXISTS : ISC_R_SUCCESS);
 458 }
 459
 460 isc_result_t
 461 dns_peer_setkeybycharp(dns_peer_t *peer, const char *keyval) {
 462         isc_buffer_t b;
 463         dns_fixedname_t fname;
 464         dns_name_t *name;
 465         isc_result_t result;
 466
 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)
 473                 return (result);
 474
 475         name = isc_mem_get(peer->mem, sizeof(dns_name_t));
 476         if (name == NULL)
 477                 return (ISC_R_NOMEMORY);
 478
 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));
 483                 return (result);
 484         }
 485
 486         result = dns_peer_setkey(peer, &name);
 487         if (result != ISC_R_SUCCESS)
 488                 isc_mem_put(peer->mem, name, sizeof(dns_name_t));
 489
 490         return (result);
 491 }
 492
 493 isc_result_t
 494 dns_peer_settransfersource(dns_peer_t *peer,
 495                            const isc_sockaddr_t *transfer_source)
 496 {
 497         REQUIRE(DNS_PEER_VALID(peer));
 498
 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;
 503         }
 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);
 509
 510                 *peer->transfer_source = *transfer_source;
 511         }
 512         return (ISC_R_SUCCESS);
 513 }
 514
 515 isc_result_t
 516 dns_peer_gettransfersource(dns_peer_t *peer, isc_sockaddr_t *transfer_source) {
 517         REQUIRE(DNS_PEER_VALID(peer));
 518         REQUIRE(transfer_source != NULL);
 519
 520         if (peer->transfer_source == NULL)
 521                 return (ISC_R_NOTFOUND);
 522         *transfer_source = *peer->transfer_source;
 523         return (ISC_R_SUCCESS);
 524 }