Annotation of embedaddon/dhcp/server/mdb6.c, revision 1.1
1.1 ! misho 1: /*
! 2: * Copyright (C) 2010-2011 by Internet Systems Consortium, Inc. ("ISC")
! 3: * Copyright (C) 2007-2008 by Internet Systems Consortium, Inc. ("ISC")
! 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: /* TODO: assert() */
! 19: /* TODO: simplify functions, as pool is now in iaaddr */
! 20:
! 21: #include "config.h"
! 22:
! 23: #include <sys/types.h>
! 24: #include <time.h>
! 25: #include <netinet/in.h>
! 26:
! 27: #include "isc-dhcp/result.h"
! 28:
! 29: #include <stdarg.h>
! 30: #include "dhcpd.h"
! 31: #include "omapip/omapip.h"
! 32: #include "omapip/hash.h"
! 33: #include "dst/md5.h"
! 34:
! 35: HASH_FUNCTIONS(ia, unsigned char *, struct ia_xx, ia_hash_t,
! 36: ia_reference, ia_dereference, do_string_hash)
! 37:
! 38: ia_hash_t *ia_na_active;
! 39: ia_hash_t *ia_ta_active;
! 40: ia_hash_t *ia_pd_active;
! 41:
! 42: HASH_FUNCTIONS(iasubopt, struct in6_addr *, struct iasubopt, iasubopt_hash_t,
! 43: iasubopt_reference, iasubopt_dereference, do_string_hash)
! 44:
! 45: struct ipv6_pool **pools;
! 46: int num_pools;
! 47:
! 48: /*
! 49: * Create a new IAADDR/PREFIX structure.
! 50: *
! 51: * - iasubopt must be a pointer to a (struct iasubopt *) pointer previously
! 52: * initialized to NULL
! 53: */
! 54: isc_result_t
! 55: iasubopt_allocate(struct iasubopt **iasubopt, const char *file, int line) {
! 56: struct iasubopt *tmp;
! 57:
! 58: if (iasubopt == NULL) {
! 59: log_error("%s(%d): NULL pointer reference", file, line);
! 60: return ISC_R_INVALIDARG;
! 61: }
! 62: if (*iasubopt != NULL) {
! 63: log_error("%s(%d): non-NULL pointer", file, line);
! 64: return ISC_R_INVALIDARG;
! 65: }
! 66:
! 67: tmp = dmalloc(sizeof(*tmp), file, line);
! 68: if (tmp == NULL) {
! 69: return ISC_R_NOMEMORY;
! 70: }
! 71:
! 72: tmp->refcnt = 1;
! 73: tmp->state = FTS_FREE;
! 74: tmp->heap_index = -1;
! 75: tmp->plen = 255;
! 76:
! 77: *iasubopt = tmp;
! 78: return ISC_R_SUCCESS;
! 79: }
! 80:
! 81: /*
! 82: * Reference an IAADDR/PREFIX structure.
! 83: *
! 84: * - iasubopt must be a pointer to a (struct iasubopt *) pointer previously
! 85: * initialized to NULL
! 86: */
! 87: isc_result_t
! 88: iasubopt_reference(struct iasubopt **iasubopt, struct iasubopt *src,
! 89: const char *file, int line) {
! 90: if (iasubopt == NULL) {
! 91: log_error("%s(%d): NULL pointer reference", file, line);
! 92: return ISC_R_INVALIDARG;
! 93: }
! 94: if (*iasubopt != NULL) {
! 95: log_error("%s(%d): non-NULL pointer", file, line);
! 96: return ISC_R_INVALIDARG;
! 97: }
! 98: if (src == NULL) {
! 99: log_error("%s(%d): NULL pointer reference", file, line);
! 100: return ISC_R_INVALIDARG;
! 101: }
! 102: *iasubopt = src;
! 103: src->refcnt++;
! 104: return ISC_R_SUCCESS;
! 105: }
! 106:
! 107:
! 108: /*
! 109: * Dereference an IAADDR/PREFIX structure.
! 110: *
! 111: * If it is the last reference, then the memory for the
! 112: * structure is freed.
! 113: */
! 114: isc_result_t
! 115: iasubopt_dereference(struct iasubopt **iasubopt, const char *file, int line) {
! 116: struct iasubopt *tmp;
! 117:
! 118: if ((iasubopt == NULL) || (*iasubopt == NULL)) {
! 119: log_error("%s(%d): NULL pointer", file, line);
! 120: return ISC_R_INVALIDARG;
! 121: }
! 122:
! 123: tmp = *iasubopt;
! 124: *iasubopt = NULL;
! 125:
! 126: tmp->refcnt--;
! 127: if (tmp->refcnt < 0) {
! 128: log_error("%s(%d): negative refcnt", file, line);
! 129: tmp->refcnt = 0;
! 130: }
! 131: if (tmp->refcnt == 0) {
! 132: if (tmp->ia != NULL) {
! 133: ia_dereference(&(tmp->ia), file, line);
! 134: }
! 135: if (tmp->ipv6_pool != NULL) {
! 136: ipv6_pool_dereference(&(tmp->ipv6_pool), file, line);
! 137: }
! 138: if (tmp->scope != NULL) {
! 139: binding_scope_dereference(&tmp->scope, file, line);
! 140: }
! 141: dfree(tmp, file, line);
! 142: }
! 143:
! 144: return ISC_R_SUCCESS;
! 145: }
! 146:
! 147: /*
! 148: * Make the key that we use for IA.
! 149: */
! 150: isc_result_t
! 151: ia_make_key(struct data_string *key, u_int32_t iaid,
! 152: const char *duid, unsigned int duid_len,
! 153: const char *file, int line) {
! 154:
! 155: memset(key, 0, sizeof(*key));
! 156: key->len = duid_len + sizeof(iaid);
! 157: if (!buffer_allocate(&(key->buffer), key->len, file, line)) {
! 158: return ISC_R_NOMEMORY;
! 159: }
! 160: key->data = key->buffer->data;
! 161: memcpy((char *)key->data, &iaid, sizeof(iaid));
! 162: memcpy((char *)key->data + sizeof(iaid), duid, duid_len);
! 163:
! 164: return ISC_R_SUCCESS;
! 165: }
! 166:
! 167: /*
! 168: * Create a new IA structure.
! 169: *
! 170: * - ia must be a pointer to a (struct ia_xx *) pointer previously
! 171: * initialized to NULL
! 172: * - iaid and duid are values from the client
! 173: *
! 174: * XXXsk: we don't concern ourself with the byte order of the IAID,
! 175: * which might be a problem if we transfer this structure
! 176: * between machines of different byte order
! 177: */
! 178: isc_result_t
! 179: ia_allocate(struct ia_xx **ia, u_int32_t iaid,
! 180: const char *duid, unsigned int duid_len,
! 181: const char *file, int line) {
! 182: struct ia_xx *tmp;
! 183:
! 184: if (ia == NULL) {
! 185: log_error("%s(%d): NULL pointer reference", file, line);
! 186: return ISC_R_INVALIDARG;
! 187: }
! 188: if (*ia != NULL) {
! 189: log_error("%s(%d): non-NULL pointer", file, line);
! 190: return ISC_R_INVALIDARG;
! 191: }
! 192:
! 193: tmp = dmalloc(sizeof(*tmp), file, line);
! 194: if (tmp == NULL) {
! 195: return ISC_R_NOMEMORY;
! 196: }
! 197:
! 198: if (ia_make_key(&tmp->iaid_duid, iaid,
! 199: duid, duid_len, file, line) != ISC_R_SUCCESS) {
! 200: dfree(tmp, file, line);
! 201: return ISC_R_NOMEMORY;
! 202: }
! 203:
! 204: tmp->refcnt = 1;
! 205:
! 206: *ia = tmp;
! 207: return ISC_R_SUCCESS;
! 208: }
! 209:
! 210: /*
! 211: * Reference an IA structure.
! 212: *
! 213: * - ia must be a pointer to a (struct ia_xx *) pointer previously
! 214: * initialized to NULL
! 215: */
! 216: isc_result_t
! 217: ia_reference(struct ia_xx **ia, struct ia_xx *src,
! 218: const char *file, int line) {
! 219: if (ia == NULL) {
! 220: log_error("%s(%d): NULL pointer reference", file, line);
! 221: return ISC_R_INVALIDARG;
! 222: }
! 223: if (*ia != NULL) {
! 224: log_error("%s(%d): non-NULL pointer", file, line);
! 225: return ISC_R_INVALIDARG;
! 226: }
! 227: if (src == NULL) {
! 228: log_error("%s(%d): NULL pointer reference", file, line);
! 229: return ISC_R_INVALIDARG;
! 230: }
! 231: *ia = src;
! 232: src->refcnt++;
! 233: return ISC_R_SUCCESS;
! 234: }
! 235:
! 236: /*
! 237: * Dereference an IA structure.
! 238: *
! 239: * If it is the last reference, then the memory for the
! 240: * structure is freed.
! 241: */
! 242: isc_result_t
! 243: ia_dereference(struct ia_xx **ia, const char *file, int line) {
! 244: struct ia_xx *tmp;
! 245: int i;
! 246:
! 247: if ((ia == NULL) || (*ia == NULL)) {
! 248: log_error("%s(%d): NULL pointer", file, line);
! 249: return ISC_R_INVALIDARG;
! 250: }
! 251:
! 252: tmp = *ia;
! 253: *ia = NULL;
! 254:
! 255: tmp->refcnt--;
! 256: if (tmp->refcnt < 0) {
! 257: log_error("%s(%d): negative refcnt", file, line);
! 258: tmp->refcnt = 0;
! 259: }
! 260: if (tmp->refcnt == 0) {
! 261: if (tmp->iasubopt != NULL) {
! 262: for (i=0; i<tmp->num_iasubopt; i++) {
! 263: iasubopt_dereference(&(tmp->iasubopt[i]),
! 264: file, line);
! 265: }
! 266: dfree(tmp->iasubopt, file, line);
! 267: }
! 268: data_string_forget(&(tmp->iaid_duid), file, line);
! 269: dfree(tmp, file, line);
! 270: }
! 271: return ISC_R_SUCCESS;
! 272: }
! 273:
! 274:
! 275: /*
! 276: * Add an IAADDR/PREFIX entry to an IA structure.
! 277: */
! 278: isc_result_t
! 279: ia_add_iasubopt(struct ia_xx *ia, struct iasubopt *iasubopt,
! 280: const char *file, int line) {
! 281: int max;
! 282: struct iasubopt **new;
! 283:
! 284: /*
! 285: * Grow our array if we need to.
! 286: *
! 287: * Note: we pick 4 as the increment, as that seems a reasonable
! 288: * guess as to how many addresses/prefixes we might expect
! 289: * on an interface.
! 290: */
! 291: if (ia->max_iasubopt <= ia->num_iasubopt) {
! 292: max = ia->max_iasubopt + 4;
! 293: new = dmalloc(max * sizeof(struct iasubopt *), file, line);
! 294: if (new == NULL) {
! 295: return ISC_R_NOMEMORY;
! 296: }
! 297: memcpy(new, ia->iasubopt,
! 298: ia->num_iasubopt * sizeof(struct iasubopt *));
! 299: ia->iasubopt = new;
! 300: ia->max_iasubopt = max;
! 301: }
! 302:
! 303: iasubopt_reference(&(ia->iasubopt[ia->num_iasubopt]), iasubopt,
! 304: file, line);
! 305: ia->num_iasubopt++;
! 306:
! 307: return ISC_R_SUCCESS;
! 308: }
! 309:
! 310: /*
! 311: * Remove an IAADDR/PREFIX entry to an IA structure.
! 312: *
! 313: * Note: if a suboption appears more than once, then only ONE will be removed.
! 314: */
! 315: void
! 316: ia_remove_iasubopt(struct ia_xx *ia, struct iasubopt *iasubopt,
! 317: const char *file, int line) {
! 318: int i, j;
! 319:
! 320: for (i=0; i<ia->num_iasubopt; i++) {
! 321: if (ia->iasubopt[i] == iasubopt) {
! 322: /* remove this sub option */
! 323: iasubopt_dereference(&(ia->iasubopt[i]), file, line);
! 324: /* move remaining suboption pointers down one */
! 325: for (j=i+1; j < ia->num_iasubopt; j++) {
! 326: ia->iasubopt[j-1] = ia->iasubopt[j];
! 327: }
! 328: /* decrease our total count */
! 329: /* remove the back-reference in the suboption itself */
! 330: ia_dereference(&iasubopt->ia, file, line);
! 331: ia->num_iasubopt--;
! 332: return;
! 333: }
! 334: }
! 335: log_error("%s(%d): IAADDR/PREFIX not in IA", file, line);
! 336: }
! 337:
! 338: /*
! 339: * Remove all addresses/prefixes from an IA.
! 340: */
! 341: void
! 342: ia_remove_all_lease(struct ia_xx *ia, const char *file, int line) {
! 343: int i;
! 344:
! 345: for (i=0; i<ia->num_iasubopt; i++) {
! 346: ia_dereference(&(ia->iasubopt[i]->ia), file, line);
! 347: iasubopt_dereference(&(ia->iasubopt[i]), file, line);
! 348: }
! 349: ia->num_iasubopt = 0;
! 350: }
! 351:
! 352: /*
! 353: * Compare two IA.
! 354: */
! 355: isc_boolean_t
! 356: ia_equal(const struct ia_xx *a, const struct ia_xx *b)
! 357: {
! 358: isc_boolean_t found;
! 359: int i, j;
! 360:
! 361: /*
! 362: * Handle cases where one or both of the inputs is NULL.
! 363: */
! 364: if (a == NULL) {
! 365: if (b == NULL) {
! 366: return ISC_TRUE;
! 367: } else {
! 368: return ISC_FALSE;
! 369: }
! 370: }
! 371:
! 372: /*
! 373: * Check the type is the same.
! 374: */
! 375: if (a->ia_type != b->ia_type) {
! 376: return ISC_FALSE;
! 377: }
! 378:
! 379: /*
! 380: * Check the DUID is the same.
! 381: */
! 382: if (a->iaid_duid.len != b->iaid_duid.len) {
! 383: return ISC_FALSE;
! 384: }
! 385: if (memcmp(a->iaid_duid.data,
! 386: b->iaid_duid.data, a->iaid_duid.len) != 0) {
! 387: return ISC_FALSE;
! 388: }
! 389:
! 390: /*
! 391: * Make sure we have the same number of addresses/prefixes in each.
! 392: */
! 393: if (a->num_iasubopt != b->num_iasubopt) {
! 394: return ISC_FALSE;
! 395: }
! 396:
! 397: /*
! 398: * Check that each address/prefix is present in both.
! 399: */
! 400: for (i=0; i<a->num_iasubopt; i++) {
! 401: found = ISC_FALSE;
! 402: for (j=0; j<a->num_iasubopt; j++) {
! 403: if (a->iasubopt[i]->plen != b->iasubopt[i]->plen)
! 404: continue;
! 405: if (memcmp(&(a->iasubopt[i]->addr),
! 406: &(b->iasubopt[j]->addr),
! 407: sizeof(struct in6_addr)) == 0) {
! 408: found = ISC_TRUE;
! 409: break;
! 410: }
! 411: }
! 412: if (!found) {
! 413: return ISC_FALSE;
! 414: }
! 415: }
! 416:
! 417: /*
! 418: * These are the same in every way we care about.
! 419: */
! 420: return ISC_TRUE;
! 421: }
! 422:
! 423: /*
! 424: * Helper function for lease heaps.
! 425: * Makes the top of the heap the oldest lease.
! 426: */
! 427: static isc_boolean_t
! 428: lease_older(void *a, void *b) {
! 429: struct iasubopt *la = (struct iasubopt *)a;
! 430: struct iasubopt *lb = (struct iasubopt *)b;
! 431:
! 432: if (la->hard_lifetime_end_time == lb->hard_lifetime_end_time) {
! 433: return difftime(la->soft_lifetime_end_time,
! 434: lb->soft_lifetime_end_time) < 0;
! 435: } else {
! 436: return difftime(la->hard_lifetime_end_time,
! 437: lb->hard_lifetime_end_time) < 0;
! 438: }
! 439: }
! 440:
! 441: /*
! 442: * Helper function for lease address/prefix heaps.
! 443: * Callback when an address's position in the heap changes.
! 444: */
! 445: static void
! 446: lease_index_changed(void *iasubopt, unsigned int new_heap_index) {
! 447: ((struct iasubopt *)iasubopt)-> heap_index = new_heap_index;
! 448: }
! 449:
! 450:
! 451: /*
! 452: * Create a new IPv6 lease pool structure.
! 453: *
! 454: * - pool must be a pointer to a (struct ipv6_pool *) pointer previously
! 455: * initialized to NULL
! 456: */
! 457: isc_result_t
! 458: ipv6_pool_allocate(struct ipv6_pool **pool, u_int16_t type,
! 459: const struct in6_addr *start_addr, int bits,
! 460: int units, const char *file, int line) {
! 461: struct ipv6_pool *tmp;
! 462:
! 463: if (pool == NULL) {
! 464: log_error("%s(%d): NULL pointer reference", file, line);
! 465: return ISC_R_INVALIDARG;
! 466: }
! 467: if (*pool != NULL) {
! 468: log_error("%s(%d): non-NULL pointer", file, line);
! 469: return ISC_R_INVALIDARG;
! 470: }
! 471:
! 472: tmp = dmalloc(sizeof(*tmp), file, line);
! 473: if (tmp == NULL) {
! 474: return ISC_R_NOMEMORY;
! 475: }
! 476:
! 477: tmp->refcnt = 1;
! 478: tmp->pool_type = type;
! 479: tmp->start_addr = *start_addr;
! 480: tmp->bits = bits;
! 481: tmp->units = units;
! 482: if (!iasubopt_new_hash(&tmp->leases, DEFAULT_HASH_SIZE, file, line)) {
! 483: dfree(tmp, file, line);
! 484: return ISC_R_NOMEMORY;
! 485: }
! 486: if (isc_heap_create(lease_older, lease_index_changed,
! 487: 0, &(tmp->active_timeouts)) != ISC_R_SUCCESS) {
! 488: iasubopt_free_hash_table(&(tmp->leases), file, line);
! 489: dfree(tmp, file, line);
! 490: return ISC_R_NOMEMORY;
! 491: }
! 492: if (isc_heap_create(lease_older, lease_index_changed,
! 493: 0, &(tmp->inactive_timeouts)) != ISC_R_SUCCESS) {
! 494: isc_heap_destroy(&(tmp->active_timeouts));
! 495: iasubopt_free_hash_table(&(tmp->leases), file, line);
! 496: dfree(tmp, file, line);
! 497: return ISC_R_NOMEMORY;
! 498: }
! 499:
! 500: *pool = tmp;
! 501: return ISC_R_SUCCESS;
! 502: }
! 503:
! 504: /*
! 505: * Reference an IPv6 pool structure.
! 506: *
! 507: * - pool must be a pointer to a (struct pool *) pointer previously
! 508: * initialized to NULL
! 509: */
! 510: isc_result_t
! 511: ipv6_pool_reference(struct ipv6_pool **pool, struct ipv6_pool *src,
! 512: const char *file, int line) {
! 513: if (pool == NULL) {
! 514: log_error("%s(%d): NULL pointer reference", file, line);
! 515: return ISC_R_INVALIDARG;
! 516: }
! 517: if (*pool != NULL) {
! 518: log_error("%s(%d): non-NULL pointer", file, line);
! 519: return ISC_R_INVALIDARG;
! 520: }
! 521: if (src == NULL) {
! 522: log_error("%s(%d): NULL pointer reference", file, line);
! 523: return ISC_R_INVALIDARG;
! 524: }
! 525: *pool = src;
! 526: src->refcnt++;
! 527: return ISC_R_SUCCESS;
! 528: }
! 529:
! 530: /*
! 531: * Note: Each IAADDR/PREFIX in a pool is referenced by the pool. This is needed
! 532: * to prevent the lease from being garbage collected out from under the
! 533: * pool.
! 534: *
! 535: * The references are made from the hash and from the heap. The following
! 536: * helper functions dereference these when a pool is destroyed.
! 537: */
! 538:
! 539: /*
! 540: * Helper function for pool cleanup.
! 541: * Dereference each of the hash entries in a pool.
! 542: */
! 543: static isc_result_t
! 544: dereference_hash_entry(const void *name, unsigned len, void *value) {
! 545: struct iasubopt *iasubopt = (struct iasubopt *)value;
! 546:
! 547: iasubopt_dereference(&iasubopt, MDL);
! 548: return ISC_R_SUCCESS;
! 549: }
! 550:
! 551: /*
! 552: * Helper function for pool cleanup.
! 553: * Dereference each of the heap entries in a pool.
! 554: */
! 555: static void
! 556: dereference_heap_entry(void *value, void *dummy) {
! 557: struct iasubopt *iasubopt = (struct iasubopt *)value;
! 558:
! 559: iasubopt_dereference(&iasubopt, MDL);
! 560: }
! 561:
! 562:
! 563: /*
! 564: * Dereference an IPv6 pool structure.
! 565: *
! 566: * If it is the last reference, then the memory for the
! 567: * structure is freed.
! 568: */
! 569: isc_result_t
! 570: ipv6_pool_dereference(struct ipv6_pool **pool, const char *file, int line) {
! 571: struct ipv6_pool *tmp;
! 572:
! 573: if ((pool == NULL) || (*pool == NULL)) {
! 574: log_error("%s(%d): NULL pointer", file, line);
! 575: return ISC_R_INVALIDARG;
! 576: }
! 577:
! 578: tmp = *pool;
! 579: *pool = NULL;
! 580:
! 581: tmp->refcnt--;
! 582: if (tmp->refcnt < 0) {
! 583: log_error("%s(%d): negative refcnt", file, line);
! 584: tmp->refcnt = 0;
! 585: }
! 586: if (tmp->refcnt == 0) {
! 587: iasubopt_hash_foreach(tmp->leases, dereference_hash_entry);
! 588: iasubopt_free_hash_table(&(tmp->leases), file, line);
! 589: isc_heap_foreach(tmp->active_timeouts,
! 590: dereference_heap_entry, NULL);
! 591: isc_heap_destroy(&(tmp->active_timeouts));
! 592: isc_heap_foreach(tmp->inactive_timeouts,
! 593: dereference_heap_entry, NULL);
! 594: isc_heap_destroy(&(tmp->inactive_timeouts));
! 595: dfree(tmp, file, line);
! 596: }
! 597:
! 598: return ISC_R_SUCCESS;
! 599: }
! 600:
! 601: /*
! 602: * Create an address by hashing the input, and using that for
! 603: * the non-network part.
! 604: */
! 605: static void
! 606: build_address6(struct in6_addr *addr,
! 607: const struct in6_addr *net_start_addr, int net_bits,
! 608: const struct data_string *input) {
! 609: MD5_CTX ctx;
! 610: int net_bytes;
! 611: int i;
! 612: char *str;
! 613: const char *net_str;
! 614:
! 615: /*
! 616: * Use MD5 to get a nice 128 bit hash of the input.
! 617: * Yes, we know MD5 isn't cryptographically sound.
! 618: * No, we don't care.
! 619: */
! 620: MD5_Init(&ctx);
! 621: MD5_Update(&ctx, input->data, input->len);
! 622: MD5_Final((unsigned char *)addr, &ctx);
! 623:
! 624: /*
! 625: * Copy the [0..128] network bits over.
! 626: */
! 627: str = (char *)addr;
! 628: net_str = (const char *)net_start_addr;
! 629: net_bytes = net_bits / 8;
! 630: for (i = 0; i < net_bytes; i++) {
! 631: str[i] = net_str[i];
! 632: }
! 633: switch (net_bits % 8) {
! 634: case 1: str[i] = (str[i] & 0x7F) | (net_str[i] & 0x80); break;
! 635: case 2: str[i] = (str[i] & 0x3F) | (net_str[i] & 0xC0); break;
! 636: case 3: str[i] = (str[i] & 0x1F) | (net_str[i] & 0xE0); break;
! 637: case 4: str[i] = (str[i] & 0x0F) | (net_str[i] & 0xF0); break;
! 638: case 5: str[i] = (str[i] & 0x07) | (net_str[i] & 0xF8); break;
! 639: case 6: str[i] = (str[i] & 0x03) | (net_str[i] & 0xFC); break;
! 640: case 7: str[i] = (str[i] & 0x01) | (net_str[i] & 0xFE); break;
! 641: }
! 642: /* set the 'u' bit to zero for /64s. */
! 643: if (net_bits == 64)
! 644: str[8] &= ~0x02;
! 645: }
! 646:
! 647: /*
! 648: * Create a temporary address by a variant of RFC 4941 algo.
! 649: * Note: this should not be used for prefixes shorter than 64 bits.
! 650: */
! 651: static void
! 652: build_temporary6(struct in6_addr *addr,
! 653: const struct in6_addr *net_start_addr, int net_bits,
! 654: const struct data_string *input) {
! 655: static u_int8_t history[8];
! 656: static u_int32_t counter = 0;
! 657: MD5_CTX ctx;
! 658: unsigned char md[16];
! 659: extern int dst_s_random(u_int8_t *, unsigned);
! 660:
! 661: /*
! 662: * First time/time to reseed.
! 663: * Please use a good pseudo-random generator here!
! 664: */
! 665: if (counter == 0) {
! 666: if (dst_s_random(history, 8) != 8)
! 667: log_fatal("Random failed.");
! 668: }
! 669:
! 670: /*
! 671: * Use MD5 as recommended by RFC 4941.
! 672: */
! 673: MD5_Init(&ctx);
! 674: MD5_Update(&ctx, history, 8UL);
! 675: MD5_Update(&ctx, input->data, input->len);
! 676: MD5_Final(md, &ctx);
! 677:
! 678: /*
! 679: * Build the address.
! 680: */
! 681: if (net_bits == 64) {
! 682: memcpy(&addr->s6_addr[0], &net_start_addr->s6_addr[0], 8);
! 683: memcpy(&addr->s6_addr[8], md, 8);
! 684: addr->s6_addr[8] &= ~0x02;
! 685: } else {
! 686: int net_bytes;
! 687: int i;
! 688: char *str;
! 689: const char *net_str;
! 690:
! 691: /*
! 692: * Copy the [0..128] network bits over.
! 693: */
! 694: str = (char *)addr;
! 695: net_str = (const char *)net_start_addr;
! 696: net_bytes = net_bits / 8;
! 697: for (i = 0; i < net_bytes; i++) {
! 698: str[i] = net_str[i];
! 699: }
! 700: memcpy(str + net_bytes, md, 16 - net_bytes);
! 701: switch (net_bits % 8) {
! 702: case 1: str[i] = (str[i] & 0x7F) | (net_str[i] & 0x80); break;
! 703: case 2: str[i] = (str[i] & 0x3F) | (net_str[i] & 0xC0); break;
! 704: case 3: str[i] = (str[i] & 0x1F) | (net_str[i] & 0xE0); break;
! 705: case 4: str[i] = (str[i] & 0x0F) | (net_str[i] & 0xF0); break;
! 706: case 5: str[i] = (str[i] & 0x07) | (net_str[i] & 0xF8); break;
! 707: case 6: str[i] = (str[i] & 0x03) | (net_str[i] & 0xFC); break;
! 708: case 7: str[i] = (str[i] & 0x01) | (net_str[i] & 0xFE); break;
! 709: }
! 710: }
! 711:
! 712:
! 713: /*
! 714: * Save history for the next call.
! 715: */
! 716: memcpy(history, md + 8, 8);
! 717: counter++;
! 718: }
! 719:
! 720: /* Reserved Subnet Router Anycast ::0:0:0:0. */
! 721: static struct in6_addr rtany;
! 722: /* Reserved Subnet Anycasts ::fdff:ffff:ffff:ff80-::fdff:ffff:ffff:ffff. */
! 723: static struct in6_addr resany;
! 724:
! 725: /*
! 726: * Create a lease for the given address and client duid.
! 727: *
! 728: * - pool must be a pointer to a (struct pool *) pointer previously
! 729: * initialized to NULL
! 730: *
! 731: * Right now we simply hash the DUID, and if we get a collision, we hash
! 732: * again until we find a free address. We try this a fixed number of times,
! 733: * to avoid getting stuck in a loop (this is important on small pools
! 734: * where we can run out of space).
! 735: *
! 736: * We return the number of attempts that it took to find an available
! 737: * lease. This tells callers when a pool is are filling up, as
! 738: * well as an indication of how full the pool is; statistically the
! 739: * more full a pool is the more attempts must be made before finding
! 740: * a free lease. Realistically this will only happen in very full
! 741: * pools.
! 742: *
! 743: * We probably want different algorithms depending on the network size, in
! 744: * the long term.
! 745: */
! 746: isc_result_t
! 747: create_lease6(struct ipv6_pool *pool, struct iasubopt **addr,
! 748: unsigned int *attempts,
! 749: const struct data_string *uid, time_t soft_lifetime_end_time) {
! 750: struct data_string ds;
! 751: struct in6_addr tmp;
! 752: struct iasubopt *test_iaaddr;
! 753: struct data_string new_ds;
! 754: struct iasubopt *iaaddr;
! 755: isc_result_t result;
! 756: isc_boolean_t reserved_iid;
! 757: static isc_boolean_t init_resiid = ISC_FALSE;
! 758:
! 759: /*
! 760: * Fill the reserved IIDs.
! 761: */
! 762: if (!init_resiid) {
! 763: memset(&rtany, 0, 16);
! 764: memset(&resany, 0, 8);
! 765: resany.s6_addr[8] = 0xfd;
! 766: memset(&resany.s6_addr[9], 0xff, 6);
! 767: init_resiid = ISC_TRUE;
! 768: }
! 769:
! 770: /*
! 771: * Use the UID as our initial seed for the hash
! 772: */
! 773: memset(&ds, 0, sizeof(ds));
! 774: data_string_copy(&ds, (struct data_string *)uid, MDL);
! 775:
! 776: *attempts = 0;
! 777: for (;;) {
! 778: /*
! 779: * Give up at some point.
! 780: */
! 781: if (++(*attempts) > 100) {
! 782: data_string_forget(&ds, MDL);
! 783: return ISC_R_NORESOURCES;
! 784: }
! 785:
! 786: /*
! 787: * Build a resource.
! 788: */
! 789: switch (pool->pool_type) {
! 790: case D6O_IA_NA:
! 791: /* address */
! 792: build_address6(&tmp, &pool->start_addr,
! 793: pool->bits, &ds);
! 794: break;
! 795: case D6O_IA_TA:
! 796: /* temporary address */
! 797: build_temporary6(&tmp, &pool->start_addr,
! 798: pool->bits, &ds);
! 799: break;
! 800: case D6O_IA_PD:
! 801: /* prefix */
! 802: log_error("create_lease6: prefix pool.");
! 803: return ISC_R_INVALIDARG;
! 804: default:
! 805: log_error("create_lease6: untyped pool.");
! 806: return ISC_R_INVALIDARG;
! 807: }
! 808:
! 809: /*
! 810: * Avoid reserved interface IDs.
! 811: * (cf. draft-krishnan-ipv6-reserved-iids-02.txt)
! 812: */
! 813: reserved_iid = ISC_FALSE;
! 814: if (memcmp(&tmp.s6_addr[8], &rtany, 8) == 0) {
! 815: reserved_iid = ISC_TRUE;
! 816: }
! 817: if (!reserved_iid &&
! 818: (memcmp(&tmp.s6_addr[8], &resany, 7) == 0) &&
! 819: ((tmp.s6_addr[15] & 0x80) == 0x80)) {
! 820: reserved_iid = ISC_TRUE;
! 821: }
! 822:
! 823: /*
! 824: * If this address is not in use, we're happy with it
! 825: */
! 826: test_iaaddr = NULL;
! 827: if (!reserved_iid &&
! 828: (iasubopt_hash_lookup(&test_iaaddr, pool->leases,
! 829: &tmp, sizeof(tmp), MDL) == 0)) {
! 830: break;
! 831: }
! 832: if (test_iaaddr != NULL)
! 833: iasubopt_dereference(&test_iaaddr, MDL);
! 834:
! 835: /*
! 836: * Otherwise, we create a new input, adding the address
! 837: */
! 838: memset(&new_ds, 0, sizeof(new_ds));
! 839: new_ds.len = ds.len + sizeof(tmp);
! 840: if (!buffer_allocate(&new_ds.buffer, new_ds.len, MDL)) {
! 841: data_string_forget(&ds, MDL);
! 842: return ISC_R_NOMEMORY;
! 843: }
! 844: new_ds.data = new_ds.buffer->data;
! 845: memcpy(new_ds.buffer->data, ds.data, ds.len);
! 846: memcpy(new_ds.buffer->data + ds.len, &tmp, sizeof(tmp));
! 847: data_string_forget(&ds, MDL);
! 848: data_string_copy(&ds, &new_ds, MDL);
! 849: data_string_forget(&new_ds, MDL);
! 850: }
! 851:
! 852: data_string_forget(&ds, MDL);
! 853:
! 854: /*
! 855: * We're happy with the address, create an IAADDR
! 856: * to hold it.
! 857: */
! 858: iaaddr = NULL;
! 859: result = iasubopt_allocate(&iaaddr, MDL);
! 860: if (result != ISC_R_SUCCESS) {
! 861: return result;
! 862: }
! 863: iaaddr->plen = 0;
! 864: memcpy(&iaaddr->addr, &tmp, sizeof(iaaddr->addr));
! 865:
! 866: /*
! 867: * Add the lease to the pool (note state is free, not active?!).
! 868: */
! 869: result = add_lease6(pool, iaaddr, soft_lifetime_end_time);
! 870: if (result == ISC_R_SUCCESS) {
! 871: iasubopt_reference(addr, iaaddr, MDL);
! 872: }
! 873: iasubopt_dereference(&iaaddr, MDL);
! 874: return result;
! 875: }
! 876:
! 877: /*
! 878: * Put a lease in the pool directly. This is intended to be used when
! 879: * loading leases from the file.
! 880: */
! 881: isc_result_t
! 882: add_lease6(struct ipv6_pool *pool, struct iasubopt *lease,
! 883: time_t valid_lifetime_end_time) {
! 884: isc_result_t insert_result;
! 885: struct iasubopt *test_iasubopt;
! 886: struct iasubopt *tmp_iasubopt;
! 887:
! 888: /* If a state was not assigned by the caller, assume active. */
! 889: if (lease->state == 0)
! 890: lease->state = FTS_ACTIVE;
! 891:
! 892: ipv6_pool_reference(&lease->ipv6_pool, pool, MDL);
! 893:
! 894: /*
! 895: * If this IAADDR/PREFIX is already in our structures, remove the
! 896: * old one.
! 897: */
! 898: test_iasubopt = NULL;
! 899: if (iasubopt_hash_lookup(&test_iasubopt, pool->leases,
! 900: &lease->addr, sizeof(lease->addr), MDL)) {
! 901: /* XXX: we should probably ask the lease what heap it is on
! 902: * (as a consistency check).
! 903: * XXX: we should probably have one function to "put this lease
! 904: * on its heap" rather than doing these if's everywhere. If
! 905: * you add more states to this list, don't.
! 906: */
! 907: if ((test_iasubopt->state == FTS_ACTIVE) ||
! 908: (test_iasubopt->state == FTS_ABANDONED)) {
! 909: isc_heap_delete(pool->active_timeouts,
! 910: test_iasubopt->heap_index);
! 911: pool->num_active--;
! 912: } else {
! 913: isc_heap_delete(pool->inactive_timeouts,
! 914: test_iasubopt->heap_index);
! 915: pool->num_inactive--;
! 916: }
! 917:
! 918: iasubopt_hash_delete(pool->leases, &test_iasubopt->addr,
! 919: sizeof(test_iasubopt->addr), MDL);
! 920:
! 921: /*
! 922: * We're going to do a bit of evil trickery here.
! 923: *
! 924: * We need to dereference the entry once to remove our
! 925: * current reference (in test_iasubopt), and then one
! 926: * more time to remove the reference left when the
! 927: * address was added to the pool before.
! 928: */
! 929: tmp_iasubopt = test_iasubopt;
! 930: iasubopt_dereference(&test_iasubopt, MDL);
! 931: iasubopt_dereference(&tmp_iasubopt, MDL);
! 932: }
! 933:
! 934: /*
! 935: * Add IAADDR/PREFIX to our structures.
! 936: */
! 937: tmp_iasubopt = NULL;
! 938: iasubopt_reference(&tmp_iasubopt, lease, MDL);
! 939: if ((tmp_iasubopt->state == FTS_ACTIVE) ||
! 940: (tmp_iasubopt->state == FTS_ABANDONED)) {
! 941: tmp_iasubopt->hard_lifetime_end_time = valid_lifetime_end_time;
! 942: iasubopt_hash_add(pool->leases, &tmp_iasubopt->addr,
! 943: sizeof(tmp_iasubopt->addr), lease, MDL);
! 944: insert_result = isc_heap_insert(pool->active_timeouts,
! 945: tmp_iasubopt);
! 946: if (insert_result == ISC_R_SUCCESS)
! 947: pool->num_active++;
! 948: } else {
! 949: tmp_iasubopt->soft_lifetime_end_time = valid_lifetime_end_time;
! 950: insert_result = isc_heap_insert(pool->inactive_timeouts,
! 951: tmp_iasubopt);
! 952: if (insert_result == ISC_R_SUCCESS)
! 953: pool->num_inactive++;
! 954: }
! 955: if (insert_result != ISC_R_SUCCESS) {
! 956: iasubopt_hash_delete(pool->leases, &lease->addr,
! 957: sizeof(lease->addr), MDL);
! 958: iasubopt_dereference(&tmp_iasubopt, MDL);
! 959: return insert_result;
! 960: }
! 961:
! 962: /*
! 963: * Note: we intentionally leave tmp_iasubopt referenced; there
! 964: * is a reference in the heap/hash, after all.
! 965: */
! 966:
! 967: return ISC_R_SUCCESS;
! 968: }
! 969:
! 970: /*
! 971: * Determine if an address is present in a pool or not.
! 972: */
! 973: isc_boolean_t
! 974: lease6_exists(const struct ipv6_pool *pool, const struct in6_addr *addr) {
! 975: struct iasubopt *test_iaaddr;
! 976:
! 977: test_iaaddr = NULL;
! 978: if (iasubopt_hash_lookup(&test_iaaddr, pool->leases,
! 979: (void *)addr, sizeof(*addr), MDL)) {
! 980: iasubopt_dereference(&test_iaaddr, MDL);
! 981: return ISC_TRUE;
! 982: } else {
! 983: return ISC_FALSE;
! 984: }
! 985: }
! 986:
! 987: /*
! 988: * Put the lease on our active pool.
! 989: */
! 990: static isc_result_t
! 991: move_lease_to_active(struct ipv6_pool *pool, struct iasubopt *lease) {
! 992: isc_result_t insert_result;
! 993: int old_heap_index;
! 994:
! 995: old_heap_index = lease->heap_index;
! 996: insert_result = isc_heap_insert(pool->active_timeouts, lease);
! 997: if (insert_result == ISC_R_SUCCESS) {
! 998: iasubopt_hash_add(pool->leases, &lease->addr,
! 999: sizeof(lease->addr), lease, MDL);
! 1000: isc_heap_delete(pool->inactive_timeouts, old_heap_index);
! 1001: pool->num_active++;
! 1002: pool->num_inactive--;
! 1003: lease->state = FTS_ACTIVE;
! 1004: }
! 1005: return insert_result;
! 1006: }
! 1007:
! 1008: /*
! 1009: * Renew an lease in the pool.
! 1010: *
! 1011: * To do this, first set the new hard_lifetime_end_time for the resource,
! 1012: * and then invoke renew_lease6() on it.
! 1013: *
! 1014: * WARNING: lease times must only be extended, never reduced!!!
! 1015: */
! 1016: isc_result_t
! 1017: renew_lease6(struct ipv6_pool *pool, struct iasubopt *lease) {
! 1018: /*
! 1019: * If we're already active, then we can just move our expiration
! 1020: * time down the heap.
! 1021: *
! 1022: * If we're abandoned then we are already on the active list
! 1023: * but we need to retag the lease and move our expiration
! 1024: * from infinite to the current value
! 1025: *
! 1026: * Otherwise, we have to move from the inactive heap to the
! 1027: * active heap.
! 1028: */
! 1029: if (lease->state == FTS_ACTIVE) {
! 1030: isc_heap_decreased(pool->active_timeouts, lease->heap_index);
! 1031: return ISC_R_SUCCESS;
! 1032: } else if (lease->state == FTS_ABANDONED) {
! 1033: char tmp_addr[INET6_ADDRSTRLEN];
! 1034: lease->state = FTS_ACTIVE;
! 1035: isc_heap_increased(pool->active_timeouts, lease->heap_index);
! 1036: log_info("Reclaiming previously abandoned address %s",
! 1037: inet_ntop(AF_INET6, &(lease->addr), tmp_addr,
! 1038: sizeof(tmp_addr)));
! 1039: return ISC_R_SUCCESS;
! 1040: } else {
! 1041: return move_lease_to_active(pool, lease);
! 1042: }
! 1043: }
! 1044:
! 1045: /*
! 1046: * Put the lease on our inactive pool, with the specified state.
! 1047: */
! 1048: static isc_result_t
! 1049: move_lease_to_inactive(struct ipv6_pool *pool, struct iasubopt *lease,
! 1050: binding_state_t state) {
! 1051: isc_result_t insert_result;
! 1052: int old_heap_index;
! 1053:
! 1054: old_heap_index = lease->heap_index;
! 1055: insert_result = isc_heap_insert(pool->inactive_timeouts, lease);
! 1056: if (insert_result == ISC_R_SUCCESS) {
! 1057: /* Process events upon expiration. */
! 1058: if (pool->pool_type != D6O_IA_PD) {
! 1059: ddns_removals(NULL, lease);
! 1060: }
! 1061:
! 1062: /* Binding scopes are no longer valid after expiry or
! 1063: * release.
! 1064: */
! 1065: if (lease->scope != NULL) {
! 1066: binding_scope_dereference(&lease->scope, MDL);
! 1067: }
! 1068:
! 1069: iasubopt_hash_delete(pool->leases,
! 1070: &lease->addr, sizeof(lease->addr), MDL);
! 1071: isc_heap_delete(pool->active_timeouts, old_heap_index);
! 1072: lease->state = state;
! 1073: pool->num_active--;
! 1074: pool->num_inactive++;
! 1075: }
! 1076: return insert_result;
! 1077: }
! 1078:
! 1079: /*
! 1080: * Expire the oldest lease if it's lifetime_end_time is
! 1081: * older than the given time.
! 1082: *
! 1083: * - leasep must be a pointer to a (struct iasubopt *) pointer previously
! 1084: * initialized to NULL
! 1085: *
! 1086: * On return leasep has a reference to the removed entry. It is left
! 1087: * pointing to NULL if the oldest lease has not expired.
! 1088: */
! 1089: isc_result_t
! 1090: expire_lease6(struct iasubopt **leasep, struct ipv6_pool *pool, time_t now) {
! 1091: struct iasubopt *tmp;
! 1092: isc_result_t result;
! 1093:
! 1094: if (leasep == NULL) {
! 1095: log_error("%s(%d): NULL pointer reference", MDL);
! 1096: return ISC_R_INVALIDARG;
! 1097: }
! 1098: if (*leasep != NULL) {
! 1099: log_error("%s(%d): non-NULL pointer", MDL);
! 1100: return ISC_R_INVALIDARG;
! 1101: }
! 1102:
! 1103: if (pool->num_active > 0) {
! 1104: tmp = (struct iasubopt *)
! 1105: isc_heap_element(pool->active_timeouts, 1);
! 1106: if (now > tmp->hard_lifetime_end_time) {
! 1107: result = move_lease_to_inactive(pool, tmp,
! 1108: FTS_EXPIRED);
! 1109: if (result == ISC_R_SUCCESS) {
! 1110: iasubopt_reference(leasep, tmp, MDL);
! 1111: }
! 1112: return result;
! 1113: }
! 1114: }
! 1115: return ISC_R_SUCCESS;
! 1116: }
! 1117:
! 1118:
! 1119: /*
! 1120: * For a declined lease, leave it on the "active" pool, but mark
! 1121: * it as declined. Give it an infinite (well, really long) life.
! 1122: */
! 1123: isc_result_t
! 1124: decline_lease6(struct ipv6_pool *pool, struct iasubopt *lease) {
! 1125: isc_result_t result;
! 1126:
! 1127: if ((lease->state != FTS_ACTIVE) &&
! 1128: (lease->state != FTS_ABANDONED)) {
! 1129: result = move_lease_to_active(pool, lease);
! 1130: if (result != ISC_R_SUCCESS) {
! 1131: return result;
! 1132: }
! 1133: }
! 1134: lease->state = FTS_ABANDONED;
! 1135: lease->hard_lifetime_end_time = MAX_TIME;
! 1136: isc_heap_decreased(pool->active_timeouts, lease->heap_index);
! 1137: return ISC_R_SUCCESS;
! 1138: }
! 1139:
! 1140: /*
! 1141: * Put the returned lease on our inactive pool.
! 1142: */
! 1143: isc_result_t
! 1144: release_lease6(struct ipv6_pool *pool, struct iasubopt *lease) {
! 1145: if (lease->state == FTS_ACTIVE) {
! 1146: return move_lease_to_inactive(pool, lease, FTS_RELEASED);
! 1147: } else {
! 1148: return ISC_R_SUCCESS;
! 1149: }
! 1150: }
! 1151:
! 1152: /*
! 1153: * Create a prefix by hashing the input, and using that for
! 1154: * the part subject to allocation.
! 1155: */
! 1156: static void
! 1157: build_prefix6(struct in6_addr *pref,
! 1158: const struct in6_addr *net_start_pref,
! 1159: int pool_bits, int pref_bits,
! 1160: const struct data_string *input) {
! 1161: MD5_CTX ctx;
! 1162: int net_bytes;
! 1163: int i;
! 1164: char *str;
! 1165: const char *net_str;
! 1166:
! 1167: /*
! 1168: * Use MD5 to get a nice 128 bit hash of the input.
! 1169: * Yes, we know MD5 isn't cryptographically sound.
! 1170: * No, we don't care.
! 1171: */
! 1172: MD5_Init(&ctx);
! 1173: MD5_Update(&ctx, input->data, input->len);
! 1174: MD5_Final((unsigned char *)pref, &ctx);
! 1175:
! 1176: /*
! 1177: * Copy the network bits over.
! 1178: */
! 1179: str = (char *)pref;
! 1180: net_str = (const char *)net_start_pref;
! 1181: net_bytes = pool_bits / 8;
! 1182: for (i = 0; i < net_bytes; i++) {
! 1183: str[i] = net_str[i];
! 1184: }
! 1185: i = net_bytes;
! 1186: switch (pool_bits % 8) {
! 1187: case 1: str[i] = (str[i] & 0x7F) | (net_str[i] & 0x80); break;
! 1188: case 2: str[i] = (str[i] & 0x3F) | (net_str[i] & 0xC0); break;
! 1189: case 3: str[i] = (str[i] & 0x1F) | (net_str[i] & 0xE0); break;
! 1190: case 4: str[i] = (str[i] & 0x0F) | (net_str[i] & 0xF0); break;
! 1191: case 5: str[i] = (str[i] & 0x07) | (net_str[i] & 0xF8); break;
! 1192: case 6: str[i] = (str[i] & 0x03) | (net_str[i] & 0xFC); break;
! 1193: case 7: str[i] = (str[i] & 0x01) | (net_str[i] & 0xFE); break;
! 1194: }
! 1195: /*
! 1196: * Zero the remaining bits.
! 1197: */
! 1198: net_bytes = pref_bits / 8;
! 1199: for (i=net_bytes+1; i<16; i++) {
! 1200: str[i] = 0;
! 1201: }
! 1202: i = net_bytes;
! 1203: switch (pref_bits % 8) {
! 1204: case 0: str[i] &= 0; break;
! 1205: case 1: str[i] &= 0x80; break;
! 1206: case 2: str[i] &= 0xC0; break;
! 1207: case 3: str[i] &= 0xE0; break;
! 1208: case 4: str[i] &= 0xF0; break;
! 1209: case 5: str[i] &= 0xF8; break;
! 1210: case 6: str[i] &= 0xFC; break;
! 1211: case 7: str[i] &= 0xFE; break;
! 1212: }
! 1213: }
! 1214:
! 1215: /*
! 1216: * Create a lease for the given prefix and client duid.
! 1217: *
! 1218: * - pool must be a pointer to a (struct pool *) pointer previously
! 1219: * initialized to NULL
! 1220: *
! 1221: * Right now we simply hash the DUID, and if we get a collision, we hash
! 1222: * again until we find a free prefix. We try this a fixed number of times,
! 1223: * to avoid getting stuck in a loop (this is important on small pools
! 1224: * where we can run out of space).
! 1225: *
! 1226: * We return the number of attempts that it took to find an available
! 1227: * prefix. This tells callers when a pool is are filling up, as
! 1228: * well as an indication of how full the pool is; statistically the
! 1229: * more full a pool is the more attempts must be made before finding
! 1230: * a free prefix. Realistically this will only happen in very full
! 1231: * pools.
! 1232: *
! 1233: * We probably want different algorithms depending on the network size, in
! 1234: * the long term.
! 1235: */
! 1236: isc_result_t
! 1237: create_prefix6(struct ipv6_pool *pool, struct iasubopt **pref,
! 1238: unsigned int *attempts,
! 1239: const struct data_string *uid,
! 1240: time_t soft_lifetime_end_time) {
! 1241: struct data_string ds;
! 1242: struct in6_addr tmp;
! 1243: struct iasubopt *test_iapref;
! 1244: struct data_string new_ds;
! 1245: struct iasubopt *iapref;
! 1246: isc_result_t result;
! 1247:
! 1248: /*
! 1249: * Use the UID as our initial seed for the hash
! 1250: */
! 1251: memset(&ds, 0, sizeof(ds));
! 1252: data_string_copy(&ds, (struct data_string *)uid, MDL);
! 1253:
! 1254: *attempts = 0;
! 1255: for (;;) {
! 1256: /*
! 1257: * Give up at some point.
! 1258: */
! 1259: if (++(*attempts) > 10) {
! 1260: data_string_forget(&ds, MDL);
! 1261: return ISC_R_NORESOURCES;
! 1262: }
! 1263:
! 1264: /*
! 1265: * Build a prefix
! 1266: */
! 1267: build_prefix6(&tmp, &pool->start_addr,
! 1268: pool->bits, pool->units, &ds);
! 1269:
! 1270: /*
! 1271: * If this prefix is not in use, we're happy with it
! 1272: */
! 1273: test_iapref = NULL;
! 1274: if (iasubopt_hash_lookup(&test_iapref, pool->leases,
! 1275: &tmp, sizeof(tmp), MDL) == 0) {
! 1276: break;
! 1277: }
! 1278: iasubopt_dereference(&test_iapref, MDL);
! 1279:
! 1280: /*
! 1281: * Otherwise, we create a new input, adding the prefix
! 1282: */
! 1283: memset(&new_ds, 0, sizeof(new_ds));
! 1284: new_ds.len = ds.len + sizeof(tmp);
! 1285: if (!buffer_allocate(&new_ds.buffer, new_ds.len, MDL)) {
! 1286: data_string_forget(&ds, MDL);
! 1287: return ISC_R_NOMEMORY;
! 1288: }
! 1289: new_ds.data = new_ds.buffer->data;
! 1290: memcpy(new_ds.buffer->data, ds.data, ds.len);
! 1291: memcpy(new_ds.buffer->data + ds.len, &tmp, sizeof(tmp));
! 1292: data_string_forget(&ds, MDL);
! 1293: data_string_copy(&ds, &new_ds, MDL);
! 1294: data_string_forget(&new_ds, MDL);
! 1295: }
! 1296:
! 1297: data_string_forget(&ds, MDL);
! 1298:
! 1299: /*
! 1300: * We're happy with the prefix, create an IAPREFIX
! 1301: * to hold it.
! 1302: */
! 1303: iapref = NULL;
! 1304: result = iasubopt_allocate(&iapref, MDL);
! 1305: if (result != ISC_R_SUCCESS) {
! 1306: return result;
! 1307: }
! 1308: iapref->plen = (u_int8_t)pool->units;
! 1309: memcpy(&iapref->addr, &tmp, sizeof(iapref->addr));
! 1310:
! 1311: /*
! 1312: * Add the prefix to the pool (note state is free, not active?!).
! 1313: */
! 1314: result = add_lease6(pool, iapref, soft_lifetime_end_time);
! 1315: if (result == ISC_R_SUCCESS) {
! 1316: iasubopt_reference(pref, iapref, MDL);
! 1317: }
! 1318: iasubopt_dereference(&iapref, MDL);
! 1319: return result;
! 1320: }
! 1321:
! 1322: /*
! 1323: * Determine if a prefix is present in a pool or not.
! 1324: */
! 1325: isc_boolean_t
! 1326: prefix6_exists(const struct ipv6_pool *pool,
! 1327: const struct in6_addr *pref, u_int8_t plen) {
! 1328: struct iasubopt *test_iapref;
! 1329:
! 1330: if ((int)plen != pool->units)
! 1331: return ISC_FALSE;
! 1332:
! 1333: test_iapref = NULL;
! 1334: if (iasubopt_hash_lookup(&test_iapref, pool->leases,
! 1335: (void *)pref, sizeof(*pref), MDL)) {
! 1336: iasubopt_dereference(&test_iapref, MDL);
! 1337: return ISC_TRUE;
! 1338: } else {
! 1339: return ISC_FALSE;
! 1340: }
! 1341: }
! 1342:
! 1343: /*
! 1344: * Mark an IPv6 address/prefix as unavailable from a pool.
! 1345: *
! 1346: * This is used for host entries and the addresses of the server itself.
! 1347: */
! 1348: isc_result_t
! 1349: mark_lease_unavailable(struct ipv6_pool *pool, const struct in6_addr *addr) {
! 1350: struct iasubopt *dummy_iasubopt;
! 1351: isc_result_t result;
! 1352:
! 1353: dummy_iasubopt = NULL;
! 1354: result = iasubopt_allocate(&dummy_iasubopt, MDL);
! 1355: if (result == ISC_R_SUCCESS) {
! 1356: dummy_iasubopt->addr = *addr;
! 1357: iasubopt_hash_add(pool->leases, &dummy_iasubopt->addr,
! 1358: sizeof(*addr), dummy_iasubopt, MDL);
! 1359: }
! 1360: return result;
! 1361: }
! 1362:
! 1363: /*
! 1364: * Add a pool.
! 1365: */
! 1366: isc_result_t
! 1367: add_ipv6_pool(struct ipv6_pool *pool) {
! 1368: struct ipv6_pool **new_pools;
! 1369:
! 1370: new_pools = dmalloc(sizeof(struct ipv6_pool *) * (num_pools+1), MDL);
! 1371: if (new_pools == NULL) {
! 1372: return ISC_R_NOMEMORY;
! 1373: }
! 1374:
! 1375: if (num_pools > 0) {
! 1376: memcpy(new_pools, pools,
! 1377: sizeof(struct ipv6_pool *) * num_pools);
! 1378: dfree(pools, MDL);
! 1379: }
! 1380: pools = new_pools;
! 1381:
! 1382: pools[num_pools] = NULL;
! 1383: ipv6_pool_reference(&pools[num_pools], pool, MDL);
! 1384: num_pools++;
! 1385: return ISC_R_SUCCESS;
! 1386: }
! 1387:
! 1388: static void
! 1389: cleanup_old_expired(struct ipv6_pool *pool) {
! 1390: struct iasubopt *tmp;
! 1391: struct ia_xx *ia;
! 1392: struct ia_xx *ia_active;
! 1393: unsigned char *tmpd;
! 1394: time_t timeout;
! 1395:
! 1396: while (pool->num_inactive > 0) {
! 1397: tmp = (struct iasubopt *)
! 1398: isc_heap_element(pool->inactive_timeouts, 1);
! 1399: if (tmp->hard_lifetime_end_time != 0) {
! 1400: timeout = tmp->hard_lifetime_end_time;
! 1401: timeout += EXPIRED_IPV6_CLEANUP_TIME;
! 1402: } else {
! 1403: timeout = tmp->soft_lifetime_end_time;
! 1404: }
! 1405: if (cur_time < timeout) {
! 1406: break;
! 1407: }
! 1408:
! 1409: isc_heap_delete(pool->inactive_timeouts, tmp->heap_index);
! 1410: pool->num_inactive--;
! 1411:
! 1412: if (tmp->ia != NULL) {
! 1413: /*
! 1414: * Check to see if this IA is in an active list,
! 1415: * but has no remaining resources. If so, remove it
! 1416: * from the active list.
! 1417: */
! 1418: ia = NULL;
! 1419: ia_reference(&ia, tmp->ia, MDL);
! 1420: ia_remove_iasubopt(ia, tmp, MDL);
! 1421: ia_active = NULL;
! 1422: tmpd = (unsigned char *)ia->iaid_duid.data;
! 1423: if ((ia->ia_type == D6O_IA_NA) &&
! 1424: (ia->num_iasubopt <= 0) &&
! 1425: (ia_hash_lookup(&ia_active, ia_na_active, tmpd,
! 1426: ia->iaid_duid.len, MDL) == 0) &&
! 1427: (ia_active == ia)) {
! 1428: ia_hash_delete(ia_na_active, tmpd,
! 1429: ia->iaid_duid.len, MDL);
! 1430: }
! 1431: if ((ia->ia_type == D6O_IA_TA) &&
! 1432: (ia->num_iasubopt <= 0) &&
! 1433: (ia_hash_lookup(&ia_active, ia_ta_active, tmpd,
! 1434: ia->iaid_duid.len, MDL) == 0) &&
! 1435: (ia_active == ia)) {
! 1436: ia_hash_delete(ia_ta_active, tmpd,
! 1437: ia->iaid_duid.len, MDL);
! 1438: }
! 1439: if ((ia->ia_type == D6O_IA_PD) &&
! 1440: (ia->num_iasubopt <= 0) &&
! 1441: (ia_hash_lookup(&ia_active, ia_pd_active, tmpd,
! 1442: ia->iaid_duid.len, MDL) == 0) &&
! 1443: (ia_active == ia)) {
! 1444: ia_hash_delete(ia_pd_active, tmpd,
! 1445: ia->iaid_duid.len, MDL);
! 1446: }
! 1447: ia_dereference(&ia, MDL);
! 1448: }
! 1449: iasubopt_dereference(&tmp, MDL);
! 1450: }
! 1451: }
! 1452:
! 1453: static void
! 1454: lease_timeout_support(void *vpool) {
! 1455: struct ipv6_pool *pool;
! 1456: struct iasubopt *lease;
! 1457:
! 1458: pool = (struct ipv6_pool *)vpool;
! 1459: for (;;) {
! 1460: /*
! 1461: * Get the next lease scheduled to expire.
! 1462: *
! 1463: * Note that if there are no leases in the pool,
! 1464: * expire_lease6() will return ISC_R_SUCCESS with
! 1465: * a NULL lease.
! 1466: */
! 1467: lease = NULL;
! 1468: if (expire_lease6(&lease, pool, cur_time) != ISC_R_SUCCESS) {
! 1469: break;
! 1470: }
! 1471: if (lease == NULL) {
! 1472: break;
! 1473: }
! 1474:
! 1475: /* Look to see if there were ddns updates, and if
! 1476: * so, drop them.
! 1477: *
! 1478: * DH: Do we want to do this on a special 'depref'
! 1479: * timer rather than expiration timer?
! 1480: */
! 1481: if (pool->pool_type != D6O_IA_PD) {
! 1482: ddns_removals(NULL, lease);
! 1483: }
! 1484:
! 1485: write_ia(lease->ia);
! 1486:
! 1487: iasubopt_dereference(&lease, MDL);
! 1488: }
! 1489:
! 1490: /*
! 1491: * Do some cleanup of our expired leases.
! 1492: */
! 1493: cleanup_old_expired(pool);
! 1494:
! 1495: /*
! 1496: * Schedule next round of expirations.
! 1497: */
! 1498: schedule_lease_timeout(pool);
! 1499: }
! 1500:
! 1501: /*
! 1502: * For a given pool, add a timer that will remove the next
! 1503: * lease to expire.
! 1504: */
! 1505: void
! 1506: schedule_lease_timeout(struct ipv6_pool *pool) {
! 1507: struct iasubopt *tmp;
! 1508: time_t timeout;
! 1509: time_t next_timeout;
! 1510: struct timeval tv;
! 1511:
! 1512: next_timeout = MAX_TIME;
! 1513:
! 1514: if (pool->num_active > 0) {
! 1515: tmp = (struct iasubopt *)
! 1516: isc_heap_element(pool->active_timeouts, 1);
! 1517: if (tmp->hard_lifetime_end_time < next_timeout) {
! 1518: next_timeout = tmp->hard_lifetime_end_time + 1;
! 1519: }
! 1520: }
! 1521:
! 1522: if (pool->num_inactive > 0) {
! 1523: tmp = (struct iasubopt *)
! 1524: isc_heap_element(pool->inactive_timeouts, 1);
! 1525: if (tmp->hard_lifetime_end_time != 0) {
! 1526: timeout = tmp->hard_lifetime_end_time;
! 1527: timeout += EXPIRED_IPV6_CLEANUP_TIME;
! 1528: } else {
! 1529: timeout = tmp->soft_lifetime_end_time + 1;
! 1530: }
! 1531: if (timeout < next_timeout) {
! 1532: next_timeout = timeout;
! 1533: }
! 1534: }
! 1535:
! 1536: if (next_timeout < MAX_TIME) {
! 1537: tv.tv_sec = next_timeout;
! 1538: tv.tv_usec = 0;
! 1539: add_timeout(&tv, lease_timeout_support, pool,
! 1540: (tvref_t)ipv6_pool_reference,
! 1541: (tvunref_t)ipv6_pool_dereference);
! 1542: }
! 1543: }
! 1544:
! 1545: /*
! 1546: * Schedule timeouts across all pools.
! 1547: */
! 1548: void
! 1549: schedule_all_ipv6_lease_timeouts(void) {
! 1550: int i;
! 1551:
! 1552: for (i=0; i<num_pools; i++) {
! 1553: schedule_lease_timeout(pools[i]);
! 1554: }
! 1555: }
! 1556:
! 1557: /*
! 1558: * Given an address and the length of the network mask, return
! 1559: * only the network portion.
! 1560: *
! 1561: * Examples:
! 1562: *
! 1563: * "fe80::216:6fff:fe49:7d9b", length 64 = "fe80::"
! 1564: * "2001:888:1936:2:216:6fff:fe49:7d9b", length 48 = "2001:888:1936::"
! 1565: */
! 1566: static void
! 1567: ipv6_network_portion(struct in6_addr *result,
! 1568: const struct in6_addr *addr, int bits) {
! 1569: unsigned char *addrp;
! 1570: int mask_bits;
! 1571: int bytes;
! 1572: int extra_bits;
! 1573: int i;
! 1574:
! 1575: static const unsigned char bitmasks[] = {
! 1576: 0x00, 0xFE, 0xFC, 0xF8,
! 1577: 0xF0, 0xE0, 0xC0, 0x80,
! 1578: };
! 1579:
! 1580: /*
! 1581: * Sanity check our bits. ;)
! 1582: */
! 1583: if ((bits < 0) || (bits > 128)) {
! 1584: log_fatal("ipv6_network_portion: bits %d not between 0 and 128",
! 1585: bits);
! 1586: }
! 1587:
! 1588: /*
! 1589: * Copy our address portion.
! 1590: */
! 1591: *result = *addr;
! 1592: addrp = ((unsigned char *)result) + 15;
! 1593:
! 1594: /*
! 1595: * Zero out masked portion.
! 1596: */
! 1597: mask_bits = 128 - bits;
! 1598: bytes = mask_bits / 8;
! 1599: extra_bits = mask_bits % 8;
! 1600:
! 1601: for (i=0; i<bytes; i++) {
! 1602: *addrp = 0;
! 1603: addrp--;
! 1604: }
! 1605: if (extra_bits) {
! 1606: *addrp &= bitmasks[extra_bits];
! 1607: }
! 1608: }
! 1609:
! 1610: /*
! 1611: * Determine if the given address/prefix is in the pool.
! 1612: */
! 1613: isc_boolean_t
! 1614: ipv6_in_pool(const struct in6_addr *addr, const struct ipv6_pool *pool) {
! 1615: struct in6_addr tmp;
! 1616:
! 1617: ipv6_network_portion(&tmp, addr, pool->bits);
! 1618: if (memcmp(&tmp, &pool->start_addr, sizeof(tmp)) == 0) {
! 1619: return ISC_TRUE;
! 1620: } else {
! 1621: return ISC_FALSE;
! 1622: }
! 1623: }
! 1624:
! 1625: /*
! 1626: * Find the pool that contains the given address.
! 1627: *
! 1628: * - pool must be a pointer to a (struct ipv6_pool *) pointer previously
! 1629: * initialized to NULL
! 1630: */
! 1631: isc_result_t
! 1632: find_ipv6_pool(struct ipv6_pool **pool, u_int16_t type,
! 1633: const struct in6_addr *addr) {
! 1634: int i;
! 1635:
! 1636: if (pool == NULL) {
! 1637: log_error("%s(%d): NULL pointer reference", MDL);
! 1638: return ISC_R_INVALIDARG;
! 1639: }
! 1640: if (*pool != NULL) {
! 1641: log_error("%s(%d): non-NULL pointer", MDL);
! 1642: return ISC_R_INVALIDARG;
! 1643: }
! 1644:
! 1645: for (i=0; i<num_pools; i++) {
! 1646: if (pools[i]->pool_type != type)
! 1647: continue;
! 1648: if (ipv6_in_pool(addr, pools[i])) {
! 1649: ipv6_pool_reference(pool, pools[i], MDL);
! 1650: return ISC_R_SUCCESS;
! 1651: }
! 1652: }
! 1653: return ISC_R_NOTFOUND;
! 1654: }
! 1655:
! 1656: /*
! 1657: * Helper function for the various functions that act across all
! 1658: * pools.
! 1659: */
! 1660: static isc_result_t
! 1661: change_leases(struct ia_xx *ia,
! 1662: isc_result_t (*change_func)(struct ipv6_pool *,
! 1663: struct iasubopt *)) {
! 1664: isc_result_t retval;
! 1665: isc_result_t renew_retval;
! 1666: struct ipv6_pool *pool;
! 1667: struct in6_addr *addr;
! 1668: int i;
! 1669:
! 1670: retval = ISC_R_SUCCESS;
! 1671: for (i=0; i<ia->num_iasubopt; i++) {
! 1672: pool = NULL;
! 1673: addr = &ia->iasubopt[i]->addr;
! 1674: if (find_ipv6_pool(&pool, ia->ia_type,
! 1675: addr) == ISC_R_SUCCESS) {
! 1676: renew_retval = change_func(pool, ia->iasubopt[i]);
! 1677: if (renew_retval != ISC_R_SUCCESS) {
! 1678: retval = renew_retval;
! 1679: }
! 1680: }
! 1681: /* XXXsk: should we warn if we don't find a pool? */
! 1682: }
! 1683: return retval;
! 1684: }
! 1685:
! 1686: /*
! 1687: * Renew all leases in an IA from all pools.
! 1688: *
! 1689: * The new hard_lifetime_end_time should be updated for the addresses/prefixes.
! 1690: *
! 1691: * WARNING: lease times must only be extended, never reduced!!!
! 1692: */
! 1693: isc_result_t
! 1694: renew_leases(struct ia_xx *ia) {
! 1695: return change_leases(ia, renew_lease6);
! 1696: }
! 1697:
! 1698: /*
! 1699: * Release all leases in an IA from all pools.
! 1700: */
! 1701: isc_result_t
! 1702: release_leases(struct ia_xx *ia) {
! 1703: return change_leases(ia, release_lease6);
! 1704: }
! 1705:
! 1706: /*
! 1707: * Decline all leases in an IA from all pools.
! 1708: */
! 1709: isc_result_t
! 1710: decline_leases(struct ia_xx *ia) {
! 1711: return change_leases(ia, decline_lease6);
! 1712: }
! 1713:
! 1714: #ifdef DHCPv6
! 1715: /*
! 1716: * Helper function to output leases.
! 1717: */
! 1718: static int write_error;
! 1719:
! 1720: static isc_result_t
! 1721: write_ia_leases(const void *name, unsigned len, void *value) {
! 1722: struct ia_xx *ia = (struct ia_xx *)value;
! 1723:
! 1724: if (!write_error) {
! 1725: if (!write_ia(ia)) {
! 1726: write_error = 1;
! 1727: }
! 1728: }
! 1729: return ISC_R_SUCCESS;
! 1730: }
! 1731:
! 1732: /*
! 1733: * Write all DHCPv6 information.
! 1734: */
! 1735: int
! 1736: write_leases6(void) {
! 1737: write_error = 0;
! 1738: write_server_duid();
! 1739: ia_hash_foreach(ia_na_active, write_ia_leases);
! 1740: if (write_error) {
! 1741: return 0;
! 1742: }
! 1743: ia_hash_foreach(ia_ta_active, write_ia_leases);
! 1744: if (write_error) {
! 1745: return 0;
! 1746: }
! 1747: ia_hash_foreach(ia_pd_active, write_ia_leases);
! 1748: if (write_error) {
! 1749: return 0;
! 1750: }
! 1751: return 1;
! 1752: }
! 1753: #endif /* DHCPv6 */
! 1754:
! 1755: static isc_result_t
! 1756: mark_hosts_unavailable_support(const void *name, unsigned len, void *value) {
! 1757: struct host_decl *h;
! 1758: struct data_string fixed_addr;
! 1759: struct in6_addr addr;
! 1760: struct ipv6_pool *p;
! 1761:
! 1762: h = (struct host_decl *)value;
! 1763:
! 1764: /*
! 1765: * If the host has no address, we don't need to mark anything.
! 1766: */
! 1767: if (h->fixed_addr == NULL) {
! 1768: return ISC_R_SUCCESS;
! 1769: }
! 1770:
! 1771: /*
! 1772: * Evaluate the fixed address.
! 1773: */
! 1774: memset(&fixed_addr, 0, sizeof(fixed_addr));
! 1775: if (!evaluate_option_cache(&fixed_addr, NULL, NULL, NULL, NULL, NULL,
! 1776: &global_scope, h->fixed_addr, MDL)) {
! 1777: log_error("mark_hosts_unavailable: "
! 1778: "error evaluating host address.");
! 1779: return ISC_R_SUCCESS;
! 1780: }
! 1781: if (fixed_addr.len != 16) {
! 1782: log_error("mark_hosts_unavailable: "
! 1783: "host address is not 128 bits.");
! 1784: return ISC_R_SUCCESS;
! 1785: }
! 1786: memcpy(&addr, fixed_addr.data, 16);
! 1787: data_string_forget(&fixed_addr, MDL);
! 1788:
! 1789: /*
! 1790: * Find the pool holding this host, and mark the address.
! 1791: * (I suppose it is arguably valid to have a host that does not
! 1792: * sit in any pool.)
! 1793: */
! 1794: p = NULL;
! 1795: if (find_ipv6_pool(&p, D6O_IA_NA, &addr) == ISC_R_SUCCESS) {
! 1796: mark_lease_unavailable(p, &addr);
! 1797: ipv6_pool_dereference(&p, MDL);
! 1798: }
! 1799: if (find_ipv6_pool(&p, D6O_IA_TA, &addr) == ISC_R_SUCCESS) {
! 1800: mark_lease_unavailable(p, &addr);
! 1801: ipv6_pool_dereference(&p, MDL);
! 1802: }
! 1803:
! 1804: return ISC_R_SUCCESS;
! 1805: }
! 1806:
! 1807: void
! 1808: mark_hosts_unavailable(void) {
! 1809: hash_foreach(host_name_hash, mark_hosts_unavailable_support);
! 1810: }
! 1811:
! 1812: static isc_result_t
! 1813: mark_phosts_unavailable_support(const void *name, unsigned len, void *value) {
! 1814: struct host_decl *h;
! 1815: struct iaddrcidrnetlist *l;
! 1816: struct in6_addr pref;
! 1817: struct ipv6_pool *p;
! 1818:
! 1819: h = (struct host_decl *)value;
! 1820:
! 1821: /*
! 1822: * If the host has no prefix, we don't need to mark anything.
! 1823: */
! 1824: if (h->fixed_prefix == NULL) {
! 1825: return ISC_R_SUCCESS;
! 1826: }
! 1827:
! 1828: /*
! 1829: * Get the fixed prefixes.
! 1830: */
! 1831: for (l = h->fixed_prefix; l != NULL; l = l->next) {
! 1832: if (l->cidrnet.lo_addr.len != 16) {
! 1833: continue;
! 1834: }
! 1835: memcpy(&pref, l->cidrnet.lo_addr.iabuf, 16);
! 1836:
! 1837: /*
! 1838: * Find the pool holding this host, and mark the prefix.
! 1839: * (I suppose it is arguably valid to have a host that does not
! 1840: * sit in any pool.)
! 1841: */
! 1842: p = NULL;
! 1843: if (find_ipv6_pool(&p, D6O_IA_PD, &pref) != ISC_R_SUCCESS) {
! 1844: continue;
! 1845: }
! 1846: if (l->cidrnet.bits != p->units) {
! 1847: ipv6_pool_dereference(&p, MDL);
! 1848: continue;
! 1849: }
! 1850: mark_lease_unavailable(p, &pref);
! 1851: ipv6_pool_dereference(&p, MDL);
! 1852: }
! 1853:
! 1854: return ISC_R_SUCCESS;
! 1855: }
! 1856:
! 1857: void
! 1858: mark_phosts_unavailable(void) {
! 1859: hash_foreach(host_name_hash, mark_phosts_unavailable_support);
! 1860: }
! 1861:
! 1862: void
! 1863: mark_interfaces_unavailable(void) {
! 1864: struct interface_info *ip;
! 1865: int i;
! 1866: struct ipv6_pool *p;
! 1867:
! 1868: ip = interfaces;
! 1869: while (ip != NULL) {
! 1870: for (i=0; i<ip->v6address_count; i++) {
! 1871: p = NULL;
! 1872: if (find_ipv6_pool(&p, D6O_IA_NA, &ip->v6addresses[i])
! 1873: == ISC_R_SUCCESS) {
! 1874: mark_lease_unavailable(p,
! 1875: &ip->v6addresses[i]);
! 1876: ipv6_pool_dereference(&p, MDL);
! 1877: }
! 1878: if (find_ipv6_pool(&p, D6O_IA_TA, &ip->v6addresses[i])
! 1879: == ISC_R_SUCCESS) {
! 1880: mark_lease_unavailable(p,
! 1881: &ip->v6addresses[i]);
! 1882: ipv6_pool_dereference(&p, MDL);
! 1883: }
! 1884: }
! 1885: ip = ip->next;
! 1886: }
! 1887: }
! 1888:
! 1889:
! 1890: #ifdef UNIT_TEST
! 1891: #include <stdlib.h>
! 1892:
! 1893: int
! 1894: main(int argc, char *argv[]) {
! 1895: struct iasubopt *iaaddr;
! 1896: struct iasubopt *iaaddr_copy;
! 1897: u_int32_t iaid;
! 1898: struct ia_xx *ia_na;
! 1899: struct ia_xx *ia_na_copy;
! 1900: int i;
! 1901: struct in6_addr addr;
! 1902: struct ipv6_pool *pool;
! 1903: struct ipv6_pool *pool_copy;
! 1904: char addr_buf[INET6_ADDRSTRLEN];
! 1905: char *uid;
! 1906: struct data_string ds;
! 1907: struct iasubopt *expired_iaaddr;
! 1908: unsigned int attempts;
! 1909:
! 1910: /*
! 1911: * Test 0: Basic iaaddr manipulation.
! 1912: */
! 1913: iaaddr = NULL;
! 1914: if (iasubopt_allocate(&iaaddr, MDL) != ISC_R_SUCCESS) {
! 1915: printf("ERROR: iasubopt_allocate() %s:%d\n", MDL);
! 1916: return 1;
! 1917: }
! 1918: if (iaaddr->state != FTS_FREE) {
! 1919: printf("ERROR: bad state %s:%d\n", MDL);
! 1920: return 1;
! 1921: }
! 1922: if (iaaddr->heap_index != -1) {
! 1923: printf("ERROR: bad heap_index %s:%d\n", MDL);
! 1924: return 1;
! 1925: }
! 1926: iaaddr_copy = NULL;
! 1927: if (iasubopt_reference(&iaaddr_copy, iaaddr, MDL) != ISC_R_SUCCESS) {
! 1928: printf("ERROR: iasubopt_reference() %s:%d\n", MDL);
! 1929: return 1;
! 1930: }
! 1931: if (iasubopt_dereference(&iaaddr, MDL) != ISC_R_SUCCESS) {
! 1932: printf("ERROR: iasubopt_reference() %s:%d\n", MDL);
! 1933: return 1;
! 1934: }
! 1935: if (iasubopt_dereference(&iaaddr_copy, MDL) != ISC_R_SUCCESS) {
! 1936: printf("ERROR: iasubopt_reference() %s:%d\n", MDL);
! 1937: return 1;
! 1938: }
! 1939:
! 1940: /*
! 1941: * Test 1: Error iaaddr manipulation.
! 1942: */
! 1943: /* bogus allocate arguments */
! 1944: if (iasubopt_allocate(NULL, MDL) != ISC_R_INVALIDARG) {
! 1945: printf("ERROR: iasubopt_allocate() %s:%d\n", MDL);
! 1946: return 1;
! 1947: }
! 1948: iaaddr = (struct iasubopt *)1;
! 1949: if (iasubopt_allocate(&iaaddr, MDL) != ISC_R_INVALIDARG) {
! 1950: printf("ERROR: iasubopt_allocate() %s:%d\n", MDL);
! 1951: return 1;
! 1952: }
! 1953:
! 1954: /* bogus reference arguments */
! 1955: iaaddr = NULL;
! 1956: if (iasubopt_allocate(&iaaddr, MDL) != ISC_R_SUCCESS) {
! 1957: printf("ERROR: iasubopt_allocate() %s:%d\n", MDL);
! 1958: return 1;
! 1959: }
! 1960: if (iasubopt_reference(NULL, iaaddr, MDL) != ISC_R_INVALIDARG) {
! 1961: printf("ERROR: iasubopt_reference() %s:%d\n", MDL);
! 1962: return 1;
! 1963: }
! 1964: iaaddr_copy = (struct iasubopt *)1;
! 1965: if (iasubopt_reference(&iaaddr_copy, iaaddr, MDL) != ISC_R_INVALIDARG) {
! 1966: printf("ERROR: iasubopt_reference() %s:%d\n", MDL);
! 1967: return 1;
! 1968: }
! 1969: iaaddr_copy = NULL;
! 1970: if (iasubopt_reference(&iaaddr_copy, NULL, MDL) != ISC_R_INVALIDARG) {
! 1971: printf("ERROR: iasubopt_reference() %s:%d\n", MDL);
! 1972: return 1;
! 1973: }
! 1974: if (iasubopt_dereference(&iaaddr, MDL) != ISC_R_SUCCESS) {
! 1975: printf("ERROR: iasubopt_reference() %s:%d\n", MDL);
! 1976: return 1;
! 1977: }
! 1978:
! 1979: /* bogus dereference arguments */
! 1980: if (iasubopt_dereference(NULL, MDL) != ISC_R_INVALIDARG) {
! 1981: printf("ERROR: iasubopt_dereference() %s:%d\n", MDL);
! 1982: return 1;
! 1983: }
! 1984: iaaddr = NULL;
! 1985: if (iasubopt_dereference(&iaaddr, MDL) != ISC_R_INVALIDARG) {
! 1986: printf("ERROR: iasubopt_dereference() %s:%d\n", MDL);
! 1987: return 1;
! 1988: }
! 1989:
! 1990: /*
! 1991: * Test 2: Basic ia_na manipulation.
! 1992: */
! 1993: iaid = 666;
! 1994: ia_na = NULL;
! 1995: if (ia_allocate(&ia_na, iaid, "TestDUID", 8, MDL) != ISC_R_SUCCESS) {
! 1996: printf("ERROR: ia_allocate() %s:%d\n", MDL);
! 1997: return 1;
! 1998: }
! 1999: if (memcmp(ia_na->iaid_duid.data, &iaid, sizeof(iaid)) != 0) {
! 2000: printf("ERROR: bad IAID_DUID %s:%d\n", MDL);
! 2001: return 1;
! 2002: }
! 2003: if (memcmp(ia_na->iaid_duid.data+sizeof(iaid), "TestDUID", 8) != 0) {
! 2004: printf("ERROR: bad IAID_DUID %s:%d\n", MDL);
! 2005: return 1;
! 2006: }
! 2007: if (ia_na->num_iasubopt != 0) {
! 2008: printf("ERROR: bad num_iasubopt %s:%d\n", MDL);
! 2009: return 1;
! 2010: }
! 2011: ia_na_copy = NULL;
! 2012: if (ia_reference(&ia_na_copy, ia_na, MDL) != ISC_R_SUCCESS) {
! 2013: printf("ERROR: ia_reference() %s:%d\n", MDL);
! 2014: return 1;
! 2015: }
! 2016: iaaddr = NULL;
! 2017: if (iasubopt_allocate(&iaaddr, MDL) != ISC_R_SUCCESS) {
! 2018: printf("ERROR: iasubopt_allocate() %s:%d\n", MDL);
! 2019: return 1;
! 2020: }
! 2021: if (ia_add_iasubopt(ia_na, iaaddr, MDL) != ISC_R_SUCCESS) {
! 2022: printf("ERROR: ia_add_iasubopt() %s:%d\n", MDL);
! 2023: return 1;
! 2024: }
! 2025: ia_remove_iasubopt(ia_na, iaaddr, MDL);
! 2026: if (iasubopt_dereference(&iaaddr, MDL) != ISC_R_SUCCESS) {
! 2027: printf("ERROR: iasubopt_reference() %s:%d\n", MDL);
! 2028: return 1;
! 2029: }
! 2030: if (ia_dereference(&ia_na, MDL) != ISC_R_SUCCESS) {
! 2031: printf("ERROR: ia_dereference() %s:%d\n", MDL);
! 2032: return 1;
! 2033: }
! 2034: if (ia_dereference(&ia_na_copy, MDL) != ISC_R_SUCCESS) {
! 2035: printf("ERROR: ia_dereference() %s:%d\n", MDL);
! 2036: return 1;
! 2037: }
! 2038:
! 2039: /*
! 2040: * Test 3: lots of iaaddr in our ia_na
! 2041: */
! 2042:
! 2043: /* lots of iaaddr that we delete */
! 2044: iaid = 666;
! 2045: ia_na = NULL;
! 2046: if (ia_allocate(&ia_na, iaid, "TestDUID", 8, MDL) != ISC_R_SUCCESS) {
! 2047: printf("ERROR: ia_allocate() %s:%d\n", MDL);
! 2048: return 1;
! 2049: }
! 2050: for (i=0; i<100; i++) {
! 2051: iaaddr = NULL;
! 2052: if (iasubopt_allocate(&iaaddr, MDL) != ISC_R_SUCCESS) {
! 2053: printf("ERROR: iasubopt_allocate() %s:%d\n", MDL);
! 2054: return 1;
! 2055: }
! 2056: if (ia_add_iasubopt(ia_na, iaaddr, MDL) != ISC_R_SUCCESS) {
! 2057: printf("ERROR: ia_add_iasubopt() %s:%d\n", MDL);
! 2058: return 1;
! 2059: }
! 2060: if (iasubopt_dereference(&iaaddr, MDL) != ISC_R_SUCCESS) {
! 2061: printf("ERROR: iasubopt_reference() %s:%d\n", MDL);
! 2062: return 1;
! 2063: }
! 2064: }
! 2065: for (i=0; i<100; i++) {
! 2066: iaaddr = ia_na->iasubopt[random() % ia_na->num_iasubopt];
! 2067: ia_remove_iasubopt(ia_na, iaaddr, MDL);
! 2068: }
! 2069: if (ia_dereference(&ia_na, MDL) != ISC_R_SUCCESS) {
! 2070: printf("ERROR: ia_dereference() %s:%d\n", MDL);
! 2071: return 1;
! 2072: }
! 2073:
! 2074: /* lots of iaaddr, let dereference cleanup */
! 2075: iaid = 666;
! 2076: ia_na = NULL;
! 2077: if (ia_allocate(&ia_na, iaid, "TestDUID", 8, MDL) != ISC_R_SUCCESS) {
! 2078: printf("ERROR: ia_allocate() %s:%d\n", MDL);
! 2079: return 1;
! 2080: }
! 2081: for (i=0; i<100; i++) {
! 2082: iaaddr = NULL;
! 2083: if (iasubopt_allocate(&iaaddr, MDL) != ISC_R_SUCCESS) {
! 2084: printf("ERROR: iasubopt_allocate() %s:%d\n", MDL);
! 2085: return 1;
! 2086: }
! 2087: if (ia_add_iasubopt(ia_na, iaaddr, MDL) != ISC_R_SUCCESS) {
! 2088: printf("ERROR: ia_add_iasubopt() %s:%d\n", MDL);
! 2089: return 1;
! 2090: }
! 2091: if (iasubopt_dereference(&iaaddr, MDL) != ISC_R_SUCCESS) {
! 2092: printf("ERROR: iasubopt_reference() %s:%d\n", MDL);
! 2093: return 1;
! 2094: }
! 2095: }
! 2096: if (ia_dereference(&ia_na, MDL) != ISC_R_SUCCESS) {
! 2097: printf("ERROR: ia_dereference() %s:%d\n", MDL);
! 2098: return 1;
! 2099: }
! 2100:
! 2101: /*
! 2102: * Test 4: Errors in ia_na.
! 2103: */
! 2104: /* bogus allocate arguments */
! 2105: if (ia_allocate(NULL, 123, "", 0, MDL) != ISC_R_INVALIDARG) {
! 2106: printf("ERROR: ia_allocate() %s:%d\n", MDL);
! 2107: return 1;
! 2108: }
! 2109: ia_na = (struct ia_na *)1;
! 2110: if (ia_allocate(&ia_na, 456, "", 0, MDL) != ISC_R_INVALIDARG) {
! 2111: printf("ERROR: ia_allocate() %s:%d\n", MDL);
! 2112: return 1;
! 2113: }
! 2114:
! 2115: /* bogus reference arguments */
! 2116: iaid = 666;
! 2117: ia_na = NULL;
! 2118: if (ia_allocate(&ia_na, iaid, "TestDUID", 8, MDL) != ISC_R_SUCCESS) {
! 2119: printf("ERROR: ia_allocate() %s:%d\n", MDL);
! 2120: return 1;
! 2121: }
! 2122: if (ia_reference(NULL, ia_na, MDL) != ISC_R_INVALIDARG) {
! 2123: printf("ERROR: ia_reference() %s:%d\n", MDL);
! 2124: return 1;
! 2125: }
! 2126: ia_na_copy = (struct ia_na *)1;
! 2127: if (ia_reference(&ia_na_copy, ia_na, MDL) != ISC_R_INVALIDARG) {
! 2128: printf("ERROR: ia_reference() %s:%d\n", MDL);
! 2129: return 1;
! 2130: }
! 2131: ia_na_copy = NULL;
! 2132: if (ia_reference(&ia_na_copy, NULL, MDL) != ISC_R_INVALIDARG) {
! 2133: printf("ERROR: ia_reference() %s:%d\n", MDL);
! 2134: return 1;
! 2135: }
! 2136: if (ia_dereference(&ia_na, MDL) != ISC_R_SUCCESS) {
! 2137: printf("ERROR: ia_dereference() %s:%d\n", MDL);
! 2138: return 1;
! 2139: }
! 2140:
! 2141: /* bogus dereference arguments */
! 2142: if (ia_dereference(NULL, MDL) != ISC_R_INVALIDARG) {
! 2143: printf("ERROR: ia_dereference() %s:%d\n", MDL);
! 2144: return 1;
! 2145: }
! 2146:
! 2147: /* bogus remove */
! 2148: iaid = 666;
! 2149: ia_na = NULL;
! 2150: if (ia_allocate(&ia_na, iaid, "TestDUID", 8, MDL) != ISC_R_SUCCESS) {
! 2151: printf("ERROR: ia_allocate() %s:%d\n", MDL);
! 2152: return 1;
! 2153: }
! 2154: ia_remove_iasubopt(ia_na, NULL, MDL);
! 2155: if (ia_dereference(&ia_na, MDL) != ISC_R_SUCCESS) {
! 2156: printf("ERROR: ia_dereference() %s:%d\n", MDL);
! 2157: return 1;
! 2158: }
! 2159:
! 2160: /*
! 2161: * Test 5: Basic ipv6_pool manipulation.
! 2162: */
! 2163:
! 2164: /* allocate, reference */
! 2165: inet_pton(AF_INET6, "1:2:3:4::", &addr);
! 2166: pool = NULL;
! 2167: if (ipv6_pool_allocate(&pool, 0, &addr, 64, 128, MDL) != ISC_R_SUCCESS) {
! 2168: printf("ERROR: ipv6_pool_allocate() %s:%d\n", MDL);
! 2169: return 1;
! 2170: }
! 2171: if (pool->num_active != 0) {
! 2172: printf("ERROR: bad num_active %s:%d\n", MDL);
! 2173: return 1;
! 2174: }
! 2175: if (pool->bits != 64) {
! 2176: printf("ERROR: bad bits %s:%d\n", MDL);
! 2177: return 1;
! 2178: }
! 2179: inet_ntop(AF_INET6, &pool->start_addr, addr_buf, sizeof(addr_buf));
! 2180: if (strcmp(inet_ntop(AF_INET6, &pool->start_addr, addr_buf,
! 2181: sizeof(addr_buf)), "1:2:3:4::") != 0) {
! 2182: printf("ERROR: bad start_addr %s:%d\n", MDL);
! 2183: return 1;
! 2184: }
! 2185: pool_copy = NULL;
! 2186: if (ipv6_pool_reference(&pool_copy, pool, MDL) != ISC_R_SUCCESS) {
! 2187: printf("ERROR: ipv6_pool_reference() %s:%d\n", MDL);
! 2188: return 1;
! 2189: }
! 2190:
! 2191: /* create_lease6, renew_lease6, expire_lease6 */
! 2192: uid = "client0";
! 2193: memset(&ds, 0, sizeof(ds));
! 2194: ds.len = strlen(uid);
! 2195: if (!buffer_allocate(&ds.buffer, ds.len, MDL)) {
! 2196: printf("Out of memory\n");
! 2197: return 1;
! 2198: }
! 2199: ds.data = ds.buffer->data;
! 2200: memcpy((char *)ds.data, uid, ds.len);
! 2201: if (create_lease6(pool, &iaaddr,
! 2202: &attempts, &ds, 1) != ISC_R_SUCCESS) {
! 2203: printf("ERROR: create_lease6() %s:%d\n", MDL);
! 2204: return 1;
! 2205: }
! 2206: if (pool->num_inactive != 1) {
! 2207: printf("ERROR: bad num_inactive %s:%d\n", MDL);
! 2208: return 1;
! 2209: }
! 2210: if (renew_lease6(pool, iaaddr) != ISC_R_SUCCESS) {
! 2211: printf("ERROR: renew_lease6() %s:%d\n", MDL);
! 2212: return 1;
! 2213: }
! 2214: if (pool->num_active != 1) {
! 2215: printf("ERROR: bad num_active %s:%d\n", MDL);
! 2216: return 1;
! 2217: }
! 2218: expired_iaaddr = NULL;
! 2219: if (expire_lease6(&expired_iaaddr, pool, 0) != ISC_R_SUCCESS) {
! 2220: printf("ERROR: expire_lease6() %s:%d\n", MDL);
! 2221: return 1;
! 2222: }
! 2223: if (expired_iaaddr != NULL) {
! 2224: printf("ERROR: should not have expired a lease %s:%d\n", MDL);
! 2225: return 1;
! 2226: }
! 2227: if (pool->num_active != 1) {
! 2228: printf("ERROR: bad num_active %s:%d\n", MDL);
! 2229: return 1;
! 2230: }
! 2231: if (expire_lease6(&expired_iaaddr, pool, 1000) != ISC_R_SUCCESS) {
! 2232: printf("ERROR: expire_lease6() %s:%d\n", MDL);
! 2233: return 1;
! 2234: }
! 2235: if (expired_iaaddr == NULL) {
! 2236: printf("ERROR: should have expired a lease %s:%d\n", MDL);
! 2237: return 1;
! 2238: }
! 2239: if (iasubopt_dereference(&expired_iaaddr, MDL) != ISC_R_SUCCESS) {
! 2240: printf("ERROR: iasubopt_dereference() %s:%d\n", MDL);
! 2241: return 1;
! 2242: }
! 2243: if (pool->num_active != 0) {
! 2244: printf("ERROR: bad num_active %s:%d\n", MDL);
! 2245: return 1;
! 2246: }
! 2247: if (iasubopt_dereference(&iaaddr, MDL) != ISC_R_SUCCESS) {
! 2248: printf("ERROR: iasubopt_dereference() %s:%d\n", MDL);
! 2249: return 1;
! 2250: }
! 2251:
! 2252: /* release_lease6, decline_lease6 */
! 2253: if (create_lease6(pool, &iaaddr, &attempts,
! 2254: &ds, 1) != ISC_R_SUCCESS) {
! 2255: printf("ERROR: create_lease6() %s:%d\n", MDL);
! 2256: return 1;
! 2257: }
! 2258: if (renew_lease6(pool, iaaddr) != ISC_R_SUCCESS) {
! 2259: printf("ERROR: renew_lease6() %s:%d\n", MDL);
! 2260: return 1;
! 2261: }
! 2262: if (pool->num_active != 1) {
! 2263: printf("ERROR: bad num_active %s:%d\n", MDL);
! 2264: return 1;
! 2265: }
! 2266: if (release_lease6(pool, iaaddr) != ISC_R_SUCCESS) {
! 2267: printf("ERROR: decline_lease6() %s:%d\n", MDL);
! 2268: return 1;
! 2269: }
! 2270: if (pool->num_active != 0) {
! 2271: printf("ERROR: bad num_active %s:%d\n", MDL);
! 2272: return 1;
! 2273: }
! 2274: if (iasubopt_dereference(&iaaddr, MDL) != ISC_R_SUCCESS) {
! 2275: printf("ERROR: iasubopt_dereference() %s:%d\n", MDL);
! 2276: return 1;
! 2277: }
! 2278: if (create_lease6(pool, &iaaddr, &attempts,
! 2279: &ds, 1) != ISC_R_SUCCESS) {
! 2280: printf("ERROR: create_lease6() %s:%d\n", MDL);
! 2281: return 1;
! 2282: }
! 2283: if (renew_lease6(pool, iaaddr) != ISC_R_SUCCESS) {
! 2284: printf("ERROR: renew_lease6() %s:%d\n", MDL);
! 2285: return 1;
! 2286: }
! 2287: if (pool->num_active != 1) {
! 2288: printf("ERROR: bad num_active %s:%d\n", MDL);
! 2289: return 1;
! 2290: }
! 2291: if (decline_lease6(pool, iaaddr) != ISC_R_SUCCESS) {
! 2292: printf("ERROR: decline_lease6() %s:%d\n", MDL);
! 2293: return 1;
! 2294: }
! 2295: if (pool->num_active != 1) {
! 2296: printf("ERROR: bad num_active %s:%d\n", MDL);
! 2297: return 1;
! 2298: }
! 2299: if (iasubopt_dereference(&iaaddr, MDL) != ISC_R_SUCCESS) {
! 2300: printf("ERROR: iasubopt_dereference() %s:%d\n", MDL);
! 2301: return 1;
! 2302: }
! 2303:
! 2304: /* dereference */
! 2305: if (ipv6_pool_dereference(&pool, MDL) != ISC_R_SUCCESS) {
! 2306: printf("ERROR: ipv6_pool_reference() %s:%d\n", MDL);
! 2307: return 1;
! 2308: }
! 2309: if (ipv6_pool_dereference(&pool_copy, MDL) != ISC_R_SUCCESS) {
! 2310: printf("ERROR: ipv6_pool_reference() %s:%d\n", MDL);
! 2311: return 1;
! 2312: }
! 2313:
! 2314: /*
! 2315: * Test 6: Error ipv6_pool manipulation
! 2316: */
! 2317: if (ipv6_pool_allocate(NULL, 0, &addr, 64, 128, MDL) != ISC_R_INVALIDARG) {
! 2318: printf("ERROR: ipv6_pool_allocate() %s:%d\n", MDL);
! 2319: return 1;
! 2320: }
! 2321: pool = (struct ipv6_pool *)1;
! 2322: if (ipv6_pool_allocate(&pool, 0, &addr, 64, 128, MDL) != ISC_R_INVALIDARG) {
! 2323: printf("ERROR: ipv6_pool_allocate() %s:%d\n", MDL);
! 2324: return 1;
! 2325: }
! 2326: if (ipv6_pool_reference(NULL, pool, MDL) != ISC_R_INVALIDARG) {
! 2327: printf("ERROR: ipv6_pool_reference() %s:%d\n", MDL);
! 2328: return 1;
! 2329: }
! 2330: pool_copy = (struct ipv6_pool *)1;
! 2331: if (ipv6_pool_reference(&pool_copy, pool, MDL) != ISC_R_INVALIDARG) {
! 2332: printf("ERROR: ipv6_pool_reference() %s:%d\n", MDL);
! 2333: return 1;
! 2334: }
! 2335: pool_copy = NULL;
! 2336: if (ipv6_pool_reference(&pool_copy, NULL, MDL) != ISC_R_INVALIDARG) {
! 2337: printf("ERROR: ipv6_pool_reference() %s:%d\n", MDL);
! 2338: return 1;
! 2339: }
! 2340: if (ipv6_pool_dereference(NULL, MDL) != ISC_R_INVALIDARG) {
! 2341: printf("ERROR: ipv6_pool_dereference() %s:%d\n", MDL);
! 2342: return 1;
! 2343: }
! 2344: if (ipv6_pool_dereference(&pool_copy, MDL) != ISC_R_INVALIDARG) {
! 2345: printf("ERROR: ipv6_pool_dereference() %s:%d\n", MDL);
! 2346: return 1;
! 2347: }
! 2348:
! 2349: /*
! 2350: * Test 7: order of expiration
! 2351: */
! 2352: pool = NULL;
! 2353: if (ipv6_pool_allocate(&pool, 0, &addr, 64, 128, MDL) != ISC_R_SUCCESS) {
! 2354: printf("ERROR: ipv6_pool_allocate() %s:%d\n", MDL);
! 2355: return 1;
! 2356: }
! 2357: for (i=10; i<100; i+=10) {
! 2358: if (create_lease6(pool, &iaaddr, &attempts,
! 2359: &ds, i) != ISC_R_SUCCESS) {
! 2360: printf("ERROR: create_lease6() %s:%d\n", MDL);
! 2361: return 1;
! 2362: }
! 2363: if (renew_lease6(pool, iaaddr) != ISC_R_SUCCESS) {
! 2364: printf("ERROR: renew_lease6() %s:%d\n", MDL);
! 2365: return 1;
! 2366: }
! 2367: if (iasubopt_dereference(&iaaddr, MDL) != ISC_R_SUCCESS) {
! 2368: printf("ERROR: iasubopt_dereference() %s:%d\n", MDL);
! 2369: return 1;
! 2370: }
! 2371: if (pool->num_active != (i / 10)) {
! 2372: printf("ERROR: bad num_active %s:%d\n", MDL);
! 2373: return 1;
! 2374: }
! 2375: }
! 2376: if (pool->num_active != 9) {
! 2377: printf("ERROR: bad num_active %s:%d\n", MDL);
! 2378: return 1;
! 2379: }
! 2380: for (i=10; i<100; i+=10) {
! 2381: if (expire_lease6(&expired_iaaddr,
! 2382: pool, 1000) != ISC_R_SUCCESS) {
! 2383: printf("ERROR: expire_lease6() %s:%d\n", MDL);
! 2384: return 1;
! 2385: }
! 2386: if (expired_iaaddr == NULL) {
! 2387: printf("ERROR: should have expired a lease %s:%d\n",
! 2388: MDL);
! 2389: return 1;
! 2390: }
! 2391: if (pool->num_active != (9 - (i / 10))) {
! 2392: printf("ERROR: bad num_active %s:%d\n", MDL);
! 2393: return 1;
! 2394: }
! 2395: if (expired_iaaddr->hard_lifetime_end_time != i) {
! 2396: printf("ERROR: bad hard_lifetime_end_time %s:%d\n",
! 2397: MDL);
! 2398: return 1;
! 2399: }
! 2400: if (iasubopt_dereference(&expired_iaaddr, MDL) !=
! 2401: ISC_R_SUCCESS) {
! 2402: printf("ERROR: iasubopt_dereference() %s:%d\n", MDL);
! 2403: return 1;
! 2404: }
! 2405: }
! 2406: if (pool->num_active != 0) {
! 2407: printf("ERROR: bad num_active %s:%d\n", MDL);
! 2408: return 1;
! 2409: }
! 2410: expired_iaaddr = NULL;
! 2411: if (expire_lease6(&expired_iaaddr, pool, 1000) != ISC_R_SUCCESS) {
! 2412: printf("ERROR: expire_lease6() %s:%d\n", MDL);
! 2413: return 1;
! 2414: }
! 2415: if (ipv6_pool_dereference(&pool, MDL) != ISC_R_SUCCESS) {
! 2416: printf("ERROR: ipv6_pool_dereference() %s:%d\n", MDL);
! 2417: return 1;
! 2418: }
! 2419:
! 2420: /*
! 2421: * Test 8: small pool
! 2422: */
! 2423: pool = NULL;
! 2424: addr.s6_addr[14] = 0x81;
! 2425: if (ipv6_pool_allocate(&pool, 0, &addr, 127, 128, MDL) != ISC_R_SUCCESS) {
! 2426: printf("ERROR: ipv6_pool_allocate() %s:%d\n", MDL);
! 2427: return 1;
! 2428: }
! 2429: if (create_lease6(pool, &iaaddr, &attempts,
! 2430: &ds, 42) != ISC_R_SUCCESS) {
! 2431: printf("ERROR: create_lease6() %s:%d\n", MDL);
! 2432: return 1;
! 2433: }
! 2434: if (renew_lease6(pool, iaaddr) != ISC_R_SUCCESS) {
! 2435: printf("ERROR: renew_lease6() %s:%d\n", MDL);
! 2436: return 1;
! 2437: }
! 2438: if (iasubopt_dereference(&iaaddr, MDL) != ISC_R_SUCCESS) {
! 2439: printf("ERROR: iasubopt_dereference() %s:%d\n", MDL);
! 2440: return 1;
! 2441: }
! 2442: if (create_lease6(pool, &iaaddr, &attempts,
! 2443: &ds, 11) != ISC_R_SUCCESS) {
! 2444: printf("ERROR: create_lease6() %s:%d\n", MDL);
! 2445: return 1;
! 2446: }
! 2447: if (renew_lease6(pool, iaaddr) != ISC_R_SUCCESS) {
! 2448: printf("ERROR: renew_lease6() %s:%d\n", MDL);
! 2449: return 1;
! 2450: }
! 2451: if (iasubopt_dereference(&iaaddr, MDL) != ISC_R_SUCCESS) {
! 2452: printf("ERROR: iasubopt_dereference() %s:%d\n", MDL);
! 2453: return 1;
! 2454: }
! 2455: if (create_lease6(pool, &iaaddr, &attempts,
! 2456: &ds, 11) != ISC_R_NORESOURCES) {
! 2457: printf("ERROR: create_lease6() %s:%d\n", MDL);
! 2458: return 1;
! 2459: }
! 2460: if (ipv6_pool_dereference(&pool, MDL) != ISC_R_SUCCESS) {
! 2461: printf("ERROR: ipv6_pool_dereference() %s:%d\n", MDL);
! 2462: return 1;
! 2463: }
! 2464: addr.s6_addr[14] = 0;
! 2465:
! 2466: /*
! 2467: * Test 9: functions across all pools
! 2468: */
! 2469: pool = NULL;
! 2470: if (ipv6_pool_allocate(&pool, 0, &addr, 64, 128, MDL) != ISC_R_SUCCESS) {
! 2471: printf("ERROR: ipv6_pool_allocate() %s:%d\n", MDL);
! 2472: return 1;
! 2473: }
! 2474: if (add_ipv6_pool(pool) != ISC_R_SUCCESS) {
! 2475: printf("ERROR: add_ipv6_pool() %s:%d\n", MDL);
! 2476: return 1;
! 2477: }
! 2478: if (ipv6_pool_dereference(&pool, MDL) != ISC_R_SUCCESS) {
! 2479: printf("ERROR: ipv6_pool_dereference() %s:%d\n", MDL);
! 2480: return 1;
! 2481: }
! 2482: pool = NULL;
! 2483: if (find_ipv6_pool(&pool, 0, &addr) != ISC_R_SUCCESS) {
! 2484: printf("ERROR: find_ipv6_pool() %s:%d\n", MDL);
! 2485: return 1;
! 2486: }
! 2487: if (ipv6_pool_dereference(&pool, MDL) != ISC_R_SUCCESS) {
! 2488: printf("ERROR: ipv6_pool_dereference() %s:%d\n", MDL);
! 2489: return 1;
! 2490: }
! 2491: inet_pton(AF_INET6, "1:2:3:4:ffff:ffff:ffff:ffff", &addr);
! 2492: pool = NULL;
! 2493: if (find_ipv6_pool(&pool, 0, &addr) != ISC_R_SUCCESS) {
! 2494: printf("ERROR: find_ipv6_pool() %s:%d\n", MDL);
! 2495: return 1;
! 2496: }
! 2497: if (ipv6_pool_dereference(&pool, MDL) != ISC_R_SUCCESS) {
! 2498: printf("ERROR: ipv6_pool_dereference() %s:%d\n", MDL);
! 2499: return 1;
! 2500: }
! 2501: inet_pton(AF_INET6, "1:2:3:5::", &addr);
! 2502: pool = NULL;
! 2503: if (find_ipv6_pool(&pool, 0, &addr) != ISC_R_NOTFOUND) {
! 2504: printf("ERROR: find_ipv6_pool() %s:%d\n", MDL);
! 2505: return 1;
! 2506: }
! 2507: inet_pton(AF_INET6, "1:2:3:3:ffff:ffff:ffff:ffff", &addr);
! 2508: pool = NULL;
! 2509: if (find_ipv6_pool(&pool, 0, &addr) != ISC_R_NOTFOUND) {
! 2510: printf("ERROR: find_ipv6_pool() %s:%d\n", MDL);
! 2511: return 1;
! 2512: }
! 2513:
! 2514: /* iaid = 666;
! 2515: ia_na = NULL;
! 2516: if (ia_allocate(&ia_na, iaid, "TestDUID", 8, MDL) != ISC_R_SUCCESS) {
! 2517: printf("ERROR: ia_allocate() %s:%d\n", MDL);
! 2518: return 1;
! 2519: }*/
! 2520:
! 2521: {
! 2522: struct in6_addr r;
! 2523: struct data_string ds;
! 2524: u_char data[16];
! 2525: char buf[64];
! 2526: int i, j;
! 2527:
! 2528: memset(&ds, 0, sizeof(ds));
! 2529: memset(data, 0xaa, sizeof(data));
! 2530: ds.len = 16;
! 2531: ds.data = data;
! 2532:
! 2533: inet_pton(AF_INET6, "3ffe:501:ffff:100::", &addr);
! 2534: for (i = 32; i < 42; i++)
! 2535: for (j = i + 1; j < 49; j++) {
! 2536: memset(&r, 0, sizeof(r));
! 2537: memset(buf, 0, 64);
! 2538: build_prefix6(&r, &addr, i, j, &ds);
! 2539: inet_ntop(AF_INET6, &r, buf, 64);
! 2540: printf("%d,%d-> %s/%d\n", i, j, buf, j);
! 2541: }
! 2542: }
! 2543:
! 2544: printf("SUCCESS: all tests passed (ignore any warning messages)\n");
! 2545: return 0;
! 2546: }
! 2547: #endif
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to mdb6.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / dhcp / server