170 #include <sys/types.h> 172 #include <netinet/in.h> 201 struct iasubopt *tmp;
203 if (iasubopt == NULL) {
204 log_error(
"%s(%d): NULL pointer reference", file, line);
207 if (*iasubopt != NULL) {
208 log_error(
"%s(%d): non-NULL pointer", file, line);
212 tmp =
dmalloc(
sizeof(*tmp), file, line);
214 return ISC_R_NOMEMORY;
223 return ISC_R_SUCCESS;
235 if (iasubopt == NULL) {
236 log_error(
"%s(%d): NULL pointer reference", file, line);
239 if (*iasubopt != NULL) {
240 log_error(
"%s(%d): non-NULL pointer", file, line);
244 log_error(
"%s(%d): NULL pointer reference", file, line);
249 return ISC_R_SUCCESS;
261 struct iasubopt *tmp;
263 if ((iasubopt == NULL) || (*iasubopt == NULL)) {
264 log_error(
"%s(%d): NULL pointer", file, line);
273 log_error(
"%s(%d): negative refcnt", file, line);
277 if (tmp->
ia != NULL) {
283 if (tmp->
scope != NULL) {
300 dfree(tmp, file, line);
303 return ISC_R_SUCCESS;
311 const char *duid,
unsigned int duid_len,
314 memset(key, 0,
sizeof(*key));
315 key->
len = duid_len +
sizeof(iaid);
317 return ISC_R_NOMEMORY;
320 memcpy((
char *)key->
data, &iaid,
sizeof(iaid));
321 memcpy((
char *)key->
data +
sizeof(iaid), duid, duid_len);
323 return ISC_R_SUCCESS;
339 const char *duid,
unsigned int duid_len,
344 log_error(
"%s(%d): NULL pointer reference", file, line);
348 log_error(
"%s(%d): non-NULL pointer", file, line);
352 tmp =
dmalloc(
sizeof(*tmp), file, line);
354 return ISC_R_NOMEMORY;
358 duid, duid_len, file, line) != ISC_R_SUCCESS) {
359 dfree(tmp, file, line);
360 return ISC_R_NOMEMORY;
366 return ISC_R_SUCCESS;
379 log_error(
"%s(%d): NULL pointer reference", file, line);
383 log_error(
"%s(%d): non-NULL pointer", file, line);
387 log_error(
"%s(%d): NULL pointer reference", file, line);
392 return ISC_R_SUCCESS;
406 if ((ia == NULL) || (*ia == NULL)) {
407 log_error(
"%s(%d): NULL pointer", file, line);
416 log_error(
"%s(%d): negative refcnt", file, line);
428 dfree(tmp, file, line);
430 return ISC_R_SUCCESS;
441 struct iasubopt **
new;
452 new =
dmalloc(max *
sizeof(
struct iasubopt *), file, line);
454 return ISC_R_NOMEMORY;
466 return ISC_R_SUCCESS;
478 if (ia == NULL || iasubopt == NULL)
496 log_error(
"%s(%d): IAADDR/PREFIX not in IA", file, line);
568 sizeof(
struct in6_addr)) == 0) {
589 lease_older(
void *a,
void *b) {
607 lease_index_changed(
void *
iasubopt,
unsigned int new_heap_index) {
636 const struct in6_addr *start_addr,
int bits,
637 int units,
const char *
file,
int line) {
641 log_error(
"%s(%d): NULL pointer reference", file, line);
645 log_error(
"%s(%d): non-NULL pointer", file, line);
649 tmp =
dmalloc(
sizeof(*tmp), file, line);
651 return ISC_R_NOMEMORY;
660 dfree(tmp, file, line);
661 return ISC_R_NOMEMORY;
665 iasubopt_free_hash_table(&(tmp->
leases), file, line);
666 dfree(tmp, file, line);
667 return ISC_R_NOMEMORY;
672 iasubopt_free_hash_table(&(tmp->
leases), file, line);
673 dfree(tmp, file, line);
674 return ISC_R_NOMEMORY;
678 return ISC_R_SUCCESS;
704 log_error(
"%s(%d): NULL pointer reference", file, line);
708 log_error(
"%s(%d): non-NULL pointer", file, line);
712 log_error(
"%s(%d): NULL pointer reference", file, line);
717 return ISC_R_SUCCESS;
734 dereference_hash_entry(
const void *name,
unsigned len,
void *value) {
738 return ISC_R_SUCCESS;
746 dereference_heap_entry(
void *value,
void *dummy) {
775 if ((pool == NULL) || (*pool == NULL)) {
776 log_error(
"%s(%d): NULL pointer", file, line);
785 log_error(
"%s(%d): negative refcnt", file, line);
789 iasubopt_hash_foreach(tmp->
leases, dereference_hash_entry);
790 iasubopt_free_hash_table(&(tmp->
leases), file, line);
792 dereference_heap_entry, NULL);
795 dereference_heap_entry, NULL);
797 dfree(tmp, file, line);
800 return ISC_R_SUCCESS;
808 build_address6(
struct in6_addr *addr,
809 const struct in6_addr *net_start_addr,
int net_bits,
823 isc_md5_update(&ctx, input->
data, input->
len);
824 isc_md5_final(&ctx, (
unsigned char *)addr);
830 net_str = (
const char *)net_start_addr;
831 net_bytes = net_bits / 8;
832 for (i = 0; i < net_bytes; i++) {
835 switch (net_bits % 8) {
836 case 1: str[i] = (str[i] & 0x7F) | (net_str[i] & 0x80);
break;
837 case 2: str[i] = (str[i] & 0x3F) | (net_str[i] & 0xC0);
break;
838 case 3: str[i] = (str[i] & 0x1F) | (net_str[i] & 0xE0);
break;
839 case 4: str[i] = (str[i] & 0x0F) | (net_str[i] & 0xF0);
break;
840 case 5: str[i] = (str[i] & 0x07) | (net_str[i] & 0xF8);
break;
841 case 6: str[i] = (str[i] & 0x03) | (net_str[i] & 0xFC);
break;
842 case 7: str[i] = (str[i] & 0x01) | (net_str[i] & 0xFE);
break;
859 build_temporary6(
struct in6_addr *addr,
860 const struct in6_addr *net_start_addr,
int net_bits,
862 static u_int32_t history[2];
863 static u_int32_t counter = 0;
865 unsigned char md[16];
872 isc_random_get(&history[0]);
873 isc_random_get(&history[1]);
880 isc_md5_update(&ctx, (
unsigned char *)&history[0], 8UL);
881 isc_md5_update(&ctx, input->
data, input->
len);
882 isc_md5_final(&ctx, md);
887 if (net_bits == 64) {
888 memcpy(&addr->s6_addr[0], &net_start_addr->s6_addr[0], 8);
889 memcpy(&addr->s6_addr[8], md, 8);
890 addr->s6_addr[8] &= ~0x02;
901 net_str = (
const char *)net_start_addr;
902 net_bytes = net_bits / 8;
903 for (i = 0; i < net_bytes; i++) {
906 memcpy(str + net_bytes, md, 16 - net_bytes);
907 switch (net_bits % 8) {
908 case 1: str[i] = (str[i] & 0x7F) | (net_str[i] & 0x80);
break;
909 case 2: str[i] = (str[i] & 0x3F) | (net_str[i] & 0xC0);
break;
910 case 3: str[i] = (str[i] & 0x1F) | (net_str[i] & 0xE0);
break;
911 case 4: str[i] = (str[i] & 0x0F) | (net_str[i] & 0xF0);
break;
912 case 5: str[i] = (str[i] & 0x07) | (net_str[i] & 0xF8);
break;
913 case 6: str[i] = (str[i] & 0x03) | (net_str[i] & 0xFC);
break;
914 case 7: str[i] = (str[i] & 0x01) | (net_str[i] & 0xFE);
break;
922 memcpy((
unsigned char *)&history[0], md + 8, 8);
927 static struct in6_addr rtany;
929 static struct in6_addr resany;
954 unsigned int *attempts,
955 const struct data_string *uid, time_t soft_lifetime_end_time) {
962 isc_boolean_t reserved_iid;
963 static isc_boolean_t init_resiid = ISC_FALSE;
969 memset(&rtany, 0, 16);
970 memset(&resany, 0, 8);
971 resany.s6_addr[8] = 0xfd;
972 memset(&resany.s6_addr[9], 0xff, 6);
973 init_resiid = ISC_TRUE;
979 memset(&ds, 0,
sizeof(ds));
987 if (++(*attempts) > 100) {
989 return ISC_R_NORESOURCES;
1008 log_error(
"create_lease6: prefix pool.");
1011 log_error(
"create_lease6: untyped pool.");
1018 reserved_iid = ISC_FALSE;
1019 if (memcmp(&tmp.s6_addr[8], &rtany.s6_addr[8], 8) == 0) {
1020 reserved_iid = ISC_TRUE;
1022 if (!reserved_iid &&
1023 (memcmp(&tmp.s6_addr[8], &resany.s6_addr[8], 7) == 0) &&
1024 ((tmp.s6_addr[15] & 0x80) == 0x80)) {
1025 reserved_iid = ISC_TRUE;
1032 if (!reserved_iid &&
1033 (iasubopt_hash_lookup(&test_iaaddr, pool->
leases,
1034 &tmp,
sizeof(tmp),
MDL) == 0)) {
1037 if (test_iaaddr != NULL)
1043 memset(&new_ds, 0,
sizeof(new_ds));
1044 new_ds.
len = ds.
len +
sizeof(tmp);
1047 return ISC_R_NOMEMORY;
1064 result = iasubopt_allocate(&iaaddr,
MDL);
1065 if (result != ISC_R_SUCCESS) {
1069 memcpy(&iaaddr->
addr, &tmp,
sizeof(iaaddr->
addr));
1074 result =
add_lease6(pool, iaaddr, soft_lifetime_end_time);
1075 if (result == ISC_R_SUCCESS) {
1129 struct iasubopt *test_iasubopt, *tmp_iasubopt;
1130 struct ia_xx *old_ia;
1131 isc_result_t status = ISC_R_SUCCESS;
1133 test_iasubopt = NULL;
1140 if (iasubopt_hash_lookup(&test_iasubopt, pool->
leases,
1143 return (ISC_R_SUCCESS);
1146 if (test_iasubopt->
ia == NULL) {
1182 status = ISC_R_FAILURE;
1200 iasubopt_hash_delete(pool->
leases, &test_iasubopt->
addr,
1201 sizeof(test_iasubopt->
addr),
MDL);
1204 ia_hash_delete(ia_table,
1214 tmp_iasubopt = test_iasubopt;
1235 time_t valid_lifetime_end_time) {
1236 isc_result_t insert_result;
1241 if (lease->
state == 0)
1250 test_iasubopt = NULL;
1251 if (iasubopt_hash_lookup(&test_iasubopt, pool->
leases,
1278 iasubopt_hash_delete(pool->
leases, &test_iasubopt->
addr,
1279 sizeof(test_iasubopt->
addr),
MDL);
1289 tmp_iasubopt = test_iasubopt;
1297 tmp_iasubopt = NULL;
1302 iasubopt_hash_add(pool->
leases, &tmp_iasubopt->
addr,
1303 sizeof(tmp_iasubopt->
addr), lease,
MDL);
1306 if (insert_result == ISC_R_SUCCESS) {
1322 if (insert_result == ISC_R_SUCCESS)
1325 if (insert_result != ISC_R_SUCCESS) {
1326 iasubopt_hash_delete(pool->
leases, &lease->
addr,
1329 return insert_result;
1337 return ISC_R_SUCCESS;
1348 if (iasubopt_hash_lookup(&test_iaaddr, pool->
leases,
1349 (
void *)addr,
sizeof(*addr),
MDL)) {
1374 isc_boolean_t status = ISC_TRUE;
1378 (
void *)&lease->
addr,
1380 if (test_iaaddr != lease) {
1394 isc_result_t insert_result;
1399 if (insert_result == ISC_R_SUCCESS) {
1400 iasubopt_hash_add(pool->
leases, &lease->
addr,
1401 sizeof(lease->
addr), lease,
MDL);
1410 return insert_result;
1457 return ISC_R_SUCCESS;
1459 char tmp_addr[INET6_ADDRSTRLEN];
1462 log_info(
"Reclaiming previously abandoned address %s",
1463 inet_ntop(AF_INET6, &(lease->
addr), tmp_addr,
1470 return ISC_R_SUCCESS;
1472 return move_lease_to_active(pool, lease);
1482 isc_result_t insert_result;
1487 if (insert_result == ISC_R_SUCCESS) {
1520 #if defined (NSUPDATE) 1530 if (lease->
scope != NULL) {
1534 iasubopt_hash_delete(pool->
leases,
1549 return insert_result;
1565 isc_result_t result;
1567 if (leasep == NULL) {
1571 if (*leasep != NULL) {
1580 result = move_lease_to_inactive(pool, tmp,
1582 if (result == ISC_R_SUCCESS) {
1588 return ISC_R_SUCCESS;
1598 isc_result_t result;
1602 result = move_lease_to_active(pool, lease);
1603 if (result != ISC_R_SUCCESS) {
1615 return ISC_R_SUCCESS;
1624 return move_lease_to_inactive(pool, lease,
FTS_RELEASED);
1626 return ISC_R_SUCCESS;
1636 const struct in6_addr *net_start_pref,
1637 int pool_bits,
int pref_bits,
1643 const char *net_str;
1651 isc_md5_update(&ctx, input->
data, input->
len);
1652 isc_md5_final(&ctx, (
unsigned char *)pref);
1658 net_str = (
const char *)net_start_pref;
1659 net_bytes = pool_bits / 8;
1660 for (i = 0; i < net_bytes; i++) {
1661 str[i] = net_str[i];
1664 switch (pool_bits % 8) {
1665 case 1: str[i] = (str[i] & 0x7F) | (net_str[i] & 0x80);
break;
1666 case 2: str[i] = (str[i] & 0x3F) | (net_str[i] & 0xC0);
break;
1667 case 3: str[i] = (str[i] & 0x1F) | (net_str[i] & 0xE0);
break;
1668 case 4: str[i] = (str[i] & 0x0F) | (net_str[i] & 0xF0);
break;
1669 case 5: str[i] = (str[i] & 0x07) | (net_str[i] & 0xF8);
break;
1670 case 6: str[i] = (str[i] & 0x03) | (net_str[i] & 0xFC);
break;
1671 case 7: str[i] = (str[i] & 0x01) | (net_str[i] & 0xFE);
break;
1676 net_bytes = pref_bits / 8;
1677 for (i=net_bytes+1; i<16; i++) {
1681 switch (pref_bits % 8) {
1682 case 0: str[i] &= 0;
break;
1683 case 1: str[i] &= 0x80;
break;
1684 case 2: str[i] &= 0xC0;
break;
1685 case 3: str[i] &= 0xE0;
break;
1686 case 4: str[i] &= 0xF0;
break;
1687 case 5: str[i] &= 0xF8;
break;
1688 case 6: str[i] &= 0xFC;
break;
1689 case 7: str[i] &= 0xFE;
break;
1716 unsigned int *attempts,
1720 struct in6_addr tmp;
1724 isc_result_t result;
1729 memset(&ds, 0,
sizeof(ds));
1737 if (++(*attempts) > 10) {
1739 return ISC_R_NORESOURCES;
1752 if (iasubopt_hash_lookup(&test_iapref, pool->
leases,
1753 &tmp,
sizeof(tmp),
MDL) == 0) {
1761 memset(&new_ds, 0,
sizeof(new_ds));
1762 new_ds.
len = ds.
len +
sizeof(tmp);
1765 return ISC_R_NOMEMORY;
1782 result = iasubopt_allocate(&iapref,
MDL);
1783 if (result != ISC_R_SUCCESS) {
1787 memcpy(&iapref->
addr, &tmp,
sizeof(iapref->
addr));
1792 result =
add_lease6(pool, iapref, soft_lifetime_end_time);
1793 if (result == ISC_R_SUCCESS) {
1805 const struct in6_addr *pref, u_int8_t
plen) {
1808 if ((
int)plen != pool->
units)
1812 if (iasubopt_hash_lookup(&test_iapref, pool->
leases,
1813 (
void *)pref,
sizeof(*pref),
MDL)) {
1829 isc_result_t result;
1831 dummy_iasubopt = NULL;
1832 result = iasubopt_allocate(&dummy_iasubopt,
MDL);
1833 if (result == ISC_R_SUCCESS) {
1835 iasubopt_hash_add(pool->
leases, &dummy_iasubopt->
addr,
1836 sizeof(*addr), dummy_iasubopt,
MDL);
1849 if (new_pools == NULL) {
1850 return ISC_R_NOMEMORY;
1854 memcpy(new_pools, pools,
1863 return ISC_R_SUCCESS;
1867 cleanup_old_expired(
struct ipv6_pool *pool) {
1870 struct ia_xx *ia_active;
1871 unsigned char *tmpd;
1890 if (tmp->
ia != NULL) {
1903 (ia_hash_lookup(&ia_active, ia_na_active, tmpd,
1905 (ia_active == ia)) {
1906 ia_hash_delete(ia_na_active, tmpd,
1911 (ia_hash_lookup(&ia_active, ia_ta_active, tmpd,
1913 (ia_active == ia)) {
1914 ia_hash_delete(ia_ta_active, tmpd,
1919 (ia_hash_lookup(&ia_active, ia_pd_active, tmpd,
1921 (ia_active == ia)) {
1922 ia_hash_delete(ia_pd_active, tmpd,
1932 lease_timeout_support(
void *vpool) {
1954 if (lease == NULL) {
1973 cleanup_old_expired(pool);
1989 time_t next_timeout;
2011 if (timeout < next_timeout) {
2012 next_timeout = timeout;
2017 tv.tv_sec = next_timeout;
2047 ipv6_network_portion(
struct in6_addr *result,
2048 const struct in6_addr *
addr,
int bits) {
2049 unsigned char *addrp;
2055 static const unsigned char bitmasks[] = {
2056 0x00, 0xFE, 0xFC, 0xF8,
2057 0xF0, 0xE0, 0xC0, 0x80,
2063 if ((bits < 0) || (bits > 128)) {
2064 log_fatal(
"ipv6_network_portion: bits %d not between 0 and 128",
2072 addrp = ((
unsigned char *)result) + 15;
2077 mask_bits = 128 - bits;
2078 bytes = mask_bits / 8;
2079 extra_bits = mask_bits % 8;
2081 for (i=0; i<bytes; i++) {
2086 *addrp &= bitmasks[extra_bits];
2095 struct in6_addr tmp;
2097 ipv6_network_portion(&tmp, addr, pool->
bits);
2098 if (memcmp(&tmp, &pool->
start_addr,
sizeof(tmp)) == 0) {
2113 const struct in6_addr *addr) {
2120 if (*pool != NULL) {
2126 if (pools[i]->pool_type != type)
2130 return ISC_R_SUCCESS;
2133 return ISC_R_NOTFOUND;
2141 change_leases(
struct ia_xx *ia,
2142 isc_result_t (*change_func)(
struct ipv6_pool *,
2144 isc_result_t retval;
2145 isc_result_t renew_retval;
2147 struct in6_addr *addr;
2150 retval = ISC_R_SUCCESS;
2155 addr) == ISC_R_SUCCESS) {
2156 renew_retval = change_func(pool, ia->
iasubopt[i]);
2157 if (renew_retval != ISC_R_SUCCESS) {
2158 retval = renew_retval;
2197 static int write_error;
2200 write_ia_leases(
const void *name,
unsigned len,
void *value) {
2208 return ISC_R_SUCCESS;
2220 nas = ia_hash_foreach(ia_na_active, write_ia_leases);
2224 tas = ia_hash_foreach(ia_ta_active, write_ia_leases);
2228 pds = ia_hash_foreach(ia_pd_active, write_ia_leases);
2233 log_info(
"Wrote %d NA, %d TA, %d PD leases to lease file.",
2240 mark_hosts_unavailable_support(
const void *name,
unsigned len,
void *value) {
2243 struct in6_addr addr;
2252 return ISC_R_SUCCESS;
2258 memset(&fixed_addr, 0,
sizeof(fixed_addr));
2262 "error evaluating host address.");
2263 return ISC_R_SUCCESS;
2265 if (fixed_addr.
len != 16) {
2267 "host address is not 128 bits.");
2268 return ISC_R_SUCCESS;
2270 memcpy(&addr, fixed_addr.
data, 16);
2288 return ISC_R_SUCCESS;
2297 mark_phosts_unavailable_support(
const void *
name,
unsigned len,
void *value) {
2300 struct in6_addr pref;
2309 return ISC_R_SUCCESS;
2338 return ISC_R_SUCCESS;
2353 while (ip != NULL) {
2395 log_error(
"%s(%d): NULL pointer reference", file, line);
2398 if (*pond != NULL) {
2399 log_error(
"%s(%d): non-NULL pointer", file, line);
2403 tmp =
dmalloc(
sizeof(*tmp), file, line);
2405 return ISC_R_NOMEMORY;
2411 return ISC_R_SUCCESS;
2437 log_error(
"%s(%d): NULL pointer reference", file, line);
2440 if (*pond != NULL) {
2441 log_error(
"%s(%d): non-NULL pointer", file, line);
2445 log_error(
"%s(%d): NULL pointer reference", file, line);
2450 return ISC_R_SUCCESS;
2477 if ((pond == NULL) || (*pond == NULL)) {
2478 log_error(
"%s(%d): NULL pointer", file, line);
2487 log_error(
"%s(%d): negative refcnt", file, line);
2491 dfree(tmp, file, line);
2494 return ISC_R_SUCCESS;
2521 char *bufptr = log_buf;
2522 size_t space_left =
sizeof(log_buf) - 1;
2530 (space_left > (INET6_ADDRSTRLEN + 6))) {
2541 bufptr, INET6_ADDRSTRLEN);
2543 used = strlen(bufptr);
2548 sprintf (bufptr,
"/%d",pool->
bits);
2549 used = strlen(bufptr);
2555 log_info(
"Threshold logging disabled for shared" 2556 " subnet of ranges: %s", log_buf);
2584 static int log_once = 0;
2586 if (htype & 0xFF00) {
2588 log_error(
"Attention: At least one client advertises a " 2589 "hardware type of %d, which exceeds the software " 2590 "limitation of 255.", htype);
2634 if (packet->
haddr) {
2637 log_debug(
"find_hosts_by_haddr6: using packet->haddr," 2638 " type: %d, len: %d", htype, hlen);
2661 memset(&rel_addr, 0,
sizeof(rel_addr));
2666 "Error evaluating option cache");
2674 hlen = rel_addr.
len - 2;
2680 "using relayed haddr" 2681 " type: %d, len: %d", htype, hlen);
2703 const unsigned char *chaddr;
2709 if (client_id->
len < 4)
2723 if (client_id->
len > 8) {
2724 hlen = client_id->
len - 8;
2725 chaddr = client_id->
data + 8;
2734 hlen = client_id->
len - 4;
2735 chaddr = client_id->
data + 4;
struct iaddrcidrnet cidrnet
void mark_interfaces_unavailable(void)
int find_hosts_by_haddr6(struct host_decl **hp, struct packet *packet, struct option_state *opt_state, const char *file, int line)
Look for hosts by MAC address if it's available.
isc_boolean_t lease6_usable(struct iasubopt *lease)
Check if address is available to a lease.
isc_result_t mark_lease_unavailable(struct ipv6_pool *pool, const struct in6_addr *addr)
struct binding_scope * global_scope
isc_boolean_t prefix6_exists(const struct ipv6_pool *pool, const struct in6_addr *pref, u_int8_t plen)
void report_jumbo_ranges()
int executable_statement_dereference(struct executable_statement **ptr, const char *file, int line)
struct shared_network * shared_networks
isc_result_t create_prefix6(struct ipv6_pool *pool, struct iasubopt **pref, unsigned int *attempts, const struct data_string *uid, time_t soft_lifetime_end_time)
isc_result_t renew_lease6(struct ipv6_pool *pool, struct iasubopt *lease)
Renew a lease in the pool.
int execute_statements(struct binding_value **result, struct packet *packet, struct lease *lease, struct client_state *client_state, struct option_state *in_options, struct option_state *out_options, struct binding_scope **scope, struct executable_statement *statements, struct on_star *on_star)
isc_result_t ia_make_key(struct data_string *key, u_int32_t iaid, const char *duid, unsigned int duid_len, const char *file, int line)
struct ipv6_pond * ipv6_pond
isc_result_t iasubopt_dereference(struct iasubopt **iasubopt, const char *file, int line)
int find_hosts_by_option(struct host_decl **, struct packet *, struct option_state *, const char *, int)
dhcp_context_t dhcp_gbl_ctx
#define DHCP_R_INVALIDARG
isc_result_t find_ipv6_pool(struct ipv6_pool **pool, u_int16_t type, const struct in6_addr *addr)
int int int log_debug(const char *,...) __attribute__((__format__(__printf__
void build_prefix6(struct in6_addr *pref, const struct in6_addr *net_start_pref, int pool_bits, int pref_bits, const struct data_string *input)
struct executable_statement * on_release
isc_result_t ia_dereference(struct ia_xx **ia, const char *file, int line)
#define D6O_CLIENT_LINKLAYER_ADDR
void data_string_forget(struct data_string *data, const char *file, int line)
isc_result_t ia_add_iasubopt(struct ia_xx *ia, struct iasubopt *iasubopt, const char *file, int line)
struct in6_addr start_addr
struct option_cache * fixed_addr
int find_hosts_by_duid_chaddr(struct host_decl **host, const struct data_string *client_id)
int log_error(const char *,...) __attribute__((__format__(__printf__
isc_result_t release_leases(struct ia_xx *ia)
int binding_scope_dereference(struct binding_scope **ptr, const char *file, int line)
struct binding_scope * scope
struct ipv6_pond * ipv6_pond
void add_timeout(struct timeval *when, void(*)(void *) where, void *what, tvref_t ref, tvunref_t unref)
void(* tvunref_t)(void *, const char *, int)
void ia_remove_all_lease(struct ia_xx *ia, const char *file, int line)
int find_hosts_by_haddr(struct host_decl **, int, const unsigned char *, unsigned, const char *, int)
isc_result_t ipv6_pool_allocate(struct ipv6_pool **pool, u_int16_t type, const struct in6_addr *start_addr, int bits, int units, const char *file, int line)
Create a new IPv6 lease pool structure.
#define EXPIRED_IPV6_CLEANUP_TIME
isc_result_t isc_heap_create(isc_heapcompare_t compare, isc_heapindex_t index, unsigned int size_increment, isc_heap_t **heapp)
Create a new heap. The heap is implemented using a space-efficient storage method. When the heap elements are deleted space is not freed but will be reused when new elements are inserted.
void(* tvref_t)(void *, void *, const char *, int)
struct option_state * options
isc_result_t ia_allocate(struct ia_xx **ia, u_int32_t iaid, const char *duid, unsigned int duid_len, const char *file, int line)
void log_fatal(const char *,...) __attribute__((__format__(__printf__
isc_result_t create_lease6(struct ipv6_pool *pool, struct iasubopt **addr, unsigned int *attempts, const struct data_string *uid, time_t soft_lifetime_end_time)
isc_boolean_t lease6_exists(const struct ipv6_pool *pool, const struct in6_addr *addr)
void isc_heap_decreased(isc_heap_t *heap, unsigned int index)
Indicates to the heap that an element's priority has decreased. This function MUST be called whenever...
time_t hard_lifetime_end_time
int evaluate_option_cache(struct data_string *result, struct packet *packet, struct lease *lease, struct client_state *client_state, struct option_state *in_options, struct option_state *cfg_options, struct binding_scope **scope, struct option_cache *oc, const char *file, int line)
host_hash_t * host_name_hash
unsigned do_string_hash(const void *, unsigned, unsigned)
struct ipv6_pool * ipv6_pool
int buffer_allocate(struct buffer **ptr, unsigned len, const char *file, int line)
isc_result_t ipv6_pond_allocate(struct ipv6_pond **pond, const char *file, int line)
Create a new IPv6 pond structure.
int write_server_duid(void)
struct iaddrcidrnetlist * next
isc_boolean_t ia_equal(const struct ia_xx *a, const struct ia_xx *b)
struct data_string iaid_duid
u_int32_t getUShort(const unsigned char *)
void dfree(void *, const char *, int)
void isc_heap_foreach(isc_heap_t *heap, isc_heapaction_t action, void *uap)
Iterate over the heap, calling an action for each element. The order of iteration is not sorted...
isc_result_t renew_leases(struct ia_xx *ia)
isc_result_t decline_leases(struct ia_xx *ia)
struct option_cache * lookup_option(struct universe *universe, struct option_state *options, unsigned code)
int int log_info(const char *,...) __attribute__((__format__(__printf__
struct ipv6_pool ** ipv6_pools
void * dmalloc(size_t, const char *, int)
struct interface_info * interfaces
int find_hosts_by_uid(struct host_decl **, const unsigned char *, unsigned, const char *, int)
isc_result_t ipv6_pool_dereference(struct ipv6_pool **pool, const char *file, int line)
de-reference an IPv6 pool structure.
isc_result_t ipv6_pool_reference(struct ipv6_pool **pool, struct ipv6_pool *src, const char *file, int line)
reference an IPv6 pool structure.
#define DEFAULT_HASH_SIZE
void isc_heap_destroy(isc_heap_t **heapp)
Destroys a heap.
struct iaddrcidrnetlist * fixed_prefix
isc_result_t ddns_removals(struct lease *, struct iasubopt *, struct dhcp_ddns_cb *, isc_boolean_t)
int commit_leases_timed(void)
void isc_heap_increased(isc_heap_t *heap, unsigned int index)
Indicates to the heap that an element's priority has increased. This function MUST be called whenever...
void isc_heap_delete(isc_heap_t *heap, unsigned int index)
Deletes an element from a heap, by element index.
int hash_foreach(struct hash_table *, hash_foreach_func)
isc_result_t add_lease6(struct ipv6_pool *pool, struct iasubopt *lease, time_t valid_lifetime_end_time)
struct interface_info * next
struct universe dhcpv6_universe
isc_heap_t * inactive_timeouts
isc_result_t iasubopt_reference(struct iasubopt **iasubopt, struct iasubopt *src, const char *file, int line)
isc_uint64_t num_abandoned
HASH_FUNCTIONS(ia, unsigned char *, struct ia_xx, ia_hash_t, ia_reference, ia_dereference, do_string_hash)
int find_hosts6(struct host_decl **host, struct packet *packet, const struct data_string *client_id, char *file, int line)
isc_uint64_t num_abandoned
isc_heap_t * active_timeouts
isc_result_t decline_lease6(struct ipv6_pool *pool, struct iasubopt *lease)
void schedule_lease_timeout(struct ipv6_pool *pool)
time_t soft_lifetime_end_time
isc_result_t ipv6_pond_dereference(struct ipv6_pond **pond, const char *file, int line)
de-reference an IPv6 pond structure.
isc_boolean_t ipv6_in_pool(const struct in6_addr *addr, const struct ipv6_pool *pool)
void mark_phosts_unavailable(void)
isc_result_t expire_lease6(struct iasubopt **leasep, struct ipv6_pool *pool, time_t now)
u_int8_t hbuf[HARDWARE_ADDR_LEN+1]
isc_result_t release_lease6(struct ipv6_pool *pool, struct iasubopt *lease)
#define HARDWARE_ADDR_LEN
void * isc_heap_element(isc_heap_t *heap, unsigned int index)
Returns the element for a specific element index.
isc_result_t ipv6_pond_reference(struct ipv6_pond **pond, struct ipv6_pond *src, const char *file, int line)
reference an IPv6 pond structure.
struct ipv6_pool ** pools
struct iasubopt ** iasubopt
int write_ia(const struct ia_xx *)
struct executable_statement * on_expiry
struct shared_network * next
isc_result_t ia_reference(struct ia_xx **ia, struct ia_xx *src, const char *file, int line)
struct executable_statement * on_commit
const unsigned char * data
isc_result_t add_ipv6_pool(struct ipv6_pool *pool)
void data_string_copy(struct data_string *dest, const struct data_string *src, const char *file, int line)
void mark_hosts_unavailable(void)
isc_result_t isc_heap_insert(isc_heap_t *heap, void *elt)
Inserts a new element into a heap.
int htype_bounds_check(uint16_t htype)
void ia_remove_iasubopt(struct ia_xx *ia, struct iasubopt *iasubopt, const char *file, int line)
isc_result_t cleanup_lease6(ia_hash_t *ia_table, struct ipv6_pool *pool, struct iasubopt *lease, struct ia_xx *ia)
Cleans up leases when reading from a lease file.
void schedule_all_ipv6_lease_timeouts(void)
struct packet * dhcpv6_container_packet
struct in6_addr * v6addresses