contrib/bind-9.2.4rc7/lib/dns/peer.c

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