/**
- * Copyright (C) 2012 Steven Barth <steven@midlink.org>
+ * Copyright (C) 2012-2013 Steven Barth <steven@midlink.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License v2 as published by
static bool dhcpv6_response_is_valid(const void *buf, ssize_t len,
const uint8_t transaction[3], enum dhcpv6_msg type);
-static time_t dhcpv6_parse_ia(void *opt, void *end);
+static uint32_t dhcpv6_parse_ia(void *opt, void *end);
static reply_handler dhcpv6_handle_reply;
static reply_handler dhcpv6_handle_advert;
static reply_handler dhcpv6_handle_rebind_reply;
static reply_handler dhcpv6_handle_reconfigure;
-static int dhcpv6_commit_advert(uint32_t elapsed);
+static int dhcpv6_commit_advert(void);
// Sockets
static int sock = -1;
-static int urandom_fd = -1;
static int ifindex = -1;
-static time_t t1 = 0, t2 = 0, t3 = 0;
+static int64_t t1 = 0, t2 = 0, t3 = 0;
// IA states
static int request_prefix = -1;
int init_dhcpv6(const char *ifname, int request_pd)
{
request_prefix = request_pd;
- urandom_fd = open("/dev/urandom", O_CLOEXEC | O_RDONLY);
- if (urandom_fd < 0)
- return -1;
sock = socket(AF_INET6, SOCK_DGRAM | SOCK_CLOEXEC, IPPROTO_UDP);
}
-void dhcpv6_remove_addrs(void)
-{
- size_t ia_na_len;
- uint8_t *odata, *ia_na = odhcp6c_get_state(STATE_IA_NA, &ia_na_len);
- uint16_t otype, olen;
- dhcpv6_for_each_option(ia_na, ia_na + ia_na_len, otype, olen, odata) {
- struct dhcpv6_ia_addr *addr = (void*)&odata[-4];
- set_rtnetlink_addr(ifindex, &addr->addr, 0, 0);
- }
-}
-
-
static void dhcpv6_send(enum dhcpv6_msg type, uint8_t trid[3], uint32_t ecs)
{
// Build FQDN
void *srv_id = odhcp6c_get_state(STATE_SERVER_ID, &srv_id_len);
// Build IA_PDs
- size_t ia_pd_len;
- void *ia_pd = odhcp6c_get_state(STATE_IA_PD, &ia_pd_len);
+ size_t ia_pd_entries, ia_pd_len = 0;
+ void *ia_pd = NULL;
+ struct odhcp6c_entry *e = odhcp6c_get_state(STATE_IA_PD, &ia_pd_entries);
+ ia_pd_entries /= sizeof(*e);
struct dhcpv6_ia_hdr hdr_ia_pd = {
htons(DHCPV6_OPT_IA_PD),
- htons(sizeof(hdr_ia_pd) - 4 + ia_pd_len),
+ htons(sizeof(hdr_ia_pd) - 4),
1, 0, 0
};
.len = htons(25), .prefix = request_prefix
};
- if (ia_pd_len == 0 && request_prefix > 0 &&
+
+ struct dhcpv6_ia_prefix p[ia_pd_entries];
+ for (size_t i = 0; i < ia_pd_entries; ++i) {
+ p[i].type = htons(DHCPV6_OPT_IA_PREFIX);
+ p[i].len = htons(sizeof(p[i]) - 4U);
+ p[i].preferred = 0;
+ p[i].valid = 0;
+ p[i].prefix = e[i].length;
+ p[i].addr = e[i].target;
+ }
+ ia_pd = p;
+ ia_pd_len = sizeof(p);
+ hdr_ia_pd.len = htons(ntohs(hdr_ia_pd.len) + ia_pd_len);
+
+ if (request_prefix > 0 &&
(type == DHCPV6_MSG_SOLICIT ||
type == DHCPV6_MSG_REQUEST)) {
ia_pd = &pref;
ia_pd_len = sizeof(pref);
+ hdr_ia_pd.len = htons(ntohs(hdr_ia_pd.len) + ia_pd_len);
}
// Build IA_NAs
- size_t ia_na_len;
- void *ia_na = odhcp6c_get_state(STATE_IA_NA, &ia_na_len);
+ size_t ia_na_entries, ia_na_len = 0;
+ void *ia_na = NULL;
+ e = odhcp6c_get_state(STATE_IA_NA, &ia_na_entries);
+ ia_na_entries /= sizeof(*e);
+
struct dhcpv6_ia_hdr hdr_ia_na = {
htons(DHCPV6_OPT_IA_NA),
- htons(sizeof(hdr_ia_na) - 4 + ia_na_len),
+ htons(sizeof(hdr_ia_na) - 4),
1, 0, 0
};
+ struct dhcpv6_ia_addr pa[ia_na_entries];
+ for (size_t i = 0; i < ia_na_entries; ++i) {
+ pa[i].type = htons(DHCPV6_OPT_IA_ADDR);
+ pa[i].len = htons(sizeof(pa[i]) - 4U);
+ pa[i].addr = e[i].target;
+ pa[i].preferred = 0;
+ pa[i].valid = 0;
+ }
+
+ ia_na = pa;
+ ia_na_len = sizeof(pa);
+ hdr_ia_na.len = htons(ntohs(hdr_ia_na.len) + ia_na_len);
+
// Reconfigure Accept
struct {
uint16_t type;
static int64_t dhcpv6_rand_delay(int64_t time)
{
int random;
- read(urandom_fd, &random, sizeof(random));
+ odhcp6c_random(&random, sizeof(random));
return (time * (random % 1000)) / 10000;
}
// Generate transaction ID
uint8_t trid[3];
- read(urandom_fd, trid, sizeof(trid));
+ odhcp6c_random(trid, sizeof(trid));
ssize_t len = -1;
int64_t rto = 0;
for (; len < 0 && round_start < round_end;
round_start = odhcp6c_get_milli_time()) {
// Check for pending signal
- if (odhcp6c_signal_is_pending())
+ if (odhcp6c_signal_process())
return -1;
// Set timeout for receiving
"%ums", (unsigned)elapsed);
if (retx->handler_reply)
- len = retx->handler_reply(type,
- opt, opt_end, elapsed / 1000);
+ len = retx->handler_reply(
+ type, opt, opt_end);
+
+ if (round_end - round_start > 1000)
+ round_end = 1000 + round_start;
}
}
// Allow
if (retx->handler_finish)
- len = retx->handler_finish(elapsed / 1000);
+ len = retx->handler_finish();
} while (len < 0 && elapsed / 1000 < timeout);
return len;
static int dhcpv6_handle_reconfigure(_unused enum dhcpv6_msg orig,
- const void *opt, const void *end, uint32_t elapsed)
+ const void *opt, const void *end)
{
// TODO: should verify the reconfigure message
uint16_t otype, olen;
odata[0] == DHCPV6_MSG_INFO_REQ))
msg = odata[0];
- t1 -= elapsed;
- t2 -= elapsed;
- t3 -= elapsed;
-
- if (t1 < 0)
- t1 = 0;
-
- if (t2 < 0)
- t2 = 0;
-
- if (t3 < 0)
- t3 = 0;
-
- dhcpv6_handle_reply(DHCPV6_MSG_UNKNOWN, NULL, NULL, elapsed);
+ dhcpv6_handle_reply(DHCPV6_MSG_UNKNOWN, NULL, NULL);
return msg;
}
// Collect all advertised servers
static int dhcpv6_handle_advert(_unused enum dhcpv6_msg orig,
- const void *opt, const void *end, _unused uint32_t elapsed)
+ const void *opt, const void *end)
{
uint16_t olen, otype;
uint8_t *odata;
cand.preference -= 2000;
} else if (otype == DHCPV6_OPT_PREF && olen >= 1 &&
cand.preference >= 0) {
- cand.preference = odata[1];
+ cand.preference = odata[0];
} else if (otype == DHCPV6_OPT_RECONF_ACCEPT) {
cand.wants_reconfigure = true;
} else if (otype == DHCPV6_OPT_IA_PD && request_prefix) {
}
-static int dhcpv6_commit_advert(_unused uint32_t elapsed)
+static int dhcpv6_commit_advert(void)
{
size_t cand_len;
struct dhcpv6_server_cand *c = NULL, *cand =
static int dhcpv6_handle_rebind_reply(enum dhcpv6_msg orig,
- const void *opt, const void *end, uint32_t elapsed)
+ const void *opt, const void *end)
{
- dhcpv6_handle_advert(orig, opt, end, elapsed);
- if (dhcpv6_commit_advert(elapsed) < 0)
+ dhcpv6_handle_advert(orig, opt, end);
+ if (dhcpv6_commit_advert() < 0) {
+ dhcpv6_handle_reply(DHCPV6_MSG_UNKNOWN, NULL, NULL);
return -1;
+ }
- return dhcpv6_handle_reply(orig, opt, end, elapsed);
+ return dhcpv6_handle_reply(orig, opt, end);
}
-static int dhcpv6_handle_reply(_unused enum dhcpv6_msg orig,
- const void *opt, const void *end, uint32_t elapsed)
+static int dhcpv6_handle_reply(enum dhcpv6_msg orig,
+ const void *opt, const void *end)
{
- uint16_t otype, olen;
uint8_t *odata;
- bool have_update = false;
-
- t1 = t2 = t3 = 86400;
-
- size_t ia_na_len, dns_len, search_len, sntp_ip_len, sntp_dns_len;
- size_t sip_ip_len, sip_fqdn_len;
- uint8_t *ia_na = odhcp6c_get_state(STATE_IA_NA, &ia_na_len);
- uint8_t *ia_end;
- odhcp6c_get_state(STATE_DNS, &dns_len);
- odhcp6c_get_state(STATE_SEARCH, &search_len);
- odhcp6c_get_state(STATE_SNTP_IP, &sntp_ip_len);
- odhcp6c_get_state(STATE_SNTP_FQDN, &sntp_dns_len);
- odhcp6c_get_state(STATE_SIP_IP, &sip_ip_len);
- odhcp6c_get_state(STATE_SIP_FQDN, &sip_fqdn_len);
-
- // Decrease valid and preferred lifetime of prefixes
- size_t ia_pd_len;
- uint8_t *ia_pd = odhcp6c_get_state(STATE_IA_PD, &ia_pd_len);
- dhcpv6_for_each_option(ia_pd, ia_pd + ia_pd_len, otype, olen, odata) {
- struct dhcpv6_ia_prefix *p = (void*)&odata[-4];
- uint32_t valid = ntohl(p->valid);
- p->valid = (valid < elapsed) ? 0 : htonl(valid - elapsed);
-
- uint32_t pref = ntohl(p->preferred);
- p->preferred = (pref < elapsed) ? 0 : htonl(pref - elapsed);
- }
+ uint16_t otype, olen;
- // Decrease valid and preferred lifetime of addresses
- dhcpv6_for_each_option(ia_na, ia_na + ia_na_len, otype, olen, odata) {
- struct dhcpv6_ia_addr *p = (void*)&odata[-4];
- uint32_t valid = ntohl(p->valid);
- p->valid = (valid < elapsed) ? 0 : htonl(valid - elapsed);
+ static time_t last_update = 0;
+ time_t now = odhcp6c_get_milli_time() / 1000;
- uint32_t pref = ntohl(p->preferred);
- p->preferred = (pref < elapsed) ? 0 : htonl(pref - elapsed);
+ uint32_t elapsed = now - last_update;
+ odhcp6c_expire();
+
+ if (orig == DHCPV6_MSG_UNKNOWN) {
+ t1 -= elapsed;
+ t2 -= elapsed;
+ t3 -= elapsed;
+
+ if (t1 < 0)
+ t1 = 0;
+
+ if (t2 < 0)
+ t2 = 0;
+
+ if (t3 < 0)
+ t3 = 0;
+ } else {
+ t1 = t2 = t3 = UINT32_MAX;
+ }
+
+ if (opt) {
+ odhcp6c_clear_state(STATE_DNS);
+ odhcp6c_clear_state(STATE_SEARCH);
+ odhcp6c_clear_state(STATE_SNTP_IP);
+ odhcp6c_clear_state(STATE_SNTP_FQDN);
+ odhcp6c_clear_state(STATE_SIP_IP);
+ odhcp6c_clear_state(STATE_SIP_FQDN);
}
// Parse and find all matching IAs
if ((otype == DHCPV6_OPT_IA_PD || otype == DHCPV6_OPT_IA_NA)
&& olen > sizeof(struct dhcpv6_ia_hdr)) {
struct dhcpv6_ia_hdr *ia_hdr = (void*)(&odata[-4]);
- time_t l_t1 = ntohl(ia_hdr->t1);
- time_t l_t2 = ntohl(ia_hdr->t2);
+ uint32_t l_t1 = ntohl(ia_hdr->t1);
+ uint32_t l_t2 = ntohl(ia_hdr->t2);
// Test ID and T1-T2 validity
if (ia_hdr->iaid != 1 || l_t2 < l_t1)
continue;
+ bool error = false;
uint16_t stype, slen;
uint8_t *sdata;
// Test status and bail if error
stype, slen, sdata)
if (stype == DHCPV6_OPT_STATUS && slen >= 2 &&
(sdata[0] || sdata[1]))
- continue;
+ error = true;
+
+ if (error)
+ continue;
// Update times
if (l_t1 > 0 && t1 > l_t1)
if (l_t2 > 0 && t2 > l_t2)
t2 = l_t2;
- // Always report update in case we have IA_PDs so that
- // the state-script is called with updated times
- if (otype == DHCPV6_OPT_IA_PD && request_prefix)
- have_update = true;
-
- time_t n = dhcpv6_parse_ia(&ia_hdr[1], odata + olen);
+ uint32_t n = dhcpv6_parse_ia(&ia_hdr[1], odata + olen);
if (n < t1)
t1 = n;
if (n < t3)
t3 = n;
+ if (t2 >= t3)
+ t2 = 8 * t3 / 10;
+
+ if (t1 >= t2)
+ t1 = 5 * t2 / 8;
+
} else if (otype == DHCPV6_OPT_DNS_SERVERS) {
- if (olen == 16)
+ if (olen % 16 == 0)
odhcp6c_add_state(STATE_DNS, odata, olen);
} else if (otype == DHCPV6_OPT_DNS_DOMAIN) {
odhcp6c_add_state(STATE_SEARCH, odata, olen);
}
}
- if (opt) {
- have_update |= odhcp6c_commit_state(STATE_DNS, dns_len);
- have_update |= odhcp6c_commit_state(STATE_SEARCH, search_len);
- have_update |= odhcp6c_commit_state(STATE_SNTP_IP,
- sntp_ip_len);
- have_update |= odhcp6c_commit_state(STATE_SNTP_FQDN,
- sntp_dns_len);
- have_update |= odhcp6c_commit_state(STATE_SIP_IP, sip_ip_len);
- have_update |= odhcp6c_commit_state(STATE_SIP_FQDN, sip_fqdn_len);
- size_t new_ia_pd_len, new_ia_na_len;
- odhcp6c_get_state(STATE_IA_PD, &new_ia_pd_len);
- odhcp6c_get_state(STATE_IA_NA, &new_ia_na_len);
- have_update |= (new_ia_pd_len != ia_pd_len) ||
- (new_ia_na_len != ia_na_len);
- }
-
- // Delete prefixes with 0 valid-time
- ia_pd = odhcp6c_get_state(STATE_IA_PD, &ia_pd_len);
- ia_end = ia_pd + ia_pd_len;
- dhcpv6_for_each_option(ia_pd, ia_end, otype, olen, odata) {
- struct dhcpv6_ia_prefix *p = (void*)&odata[-4];
- while (!p->valid) {
- ia_end = ia_pd + odhcp6c_remove_state(STATE_IA_PD,
- (uint8_t*)p - ia_pd, olen + 4);
- have_update = true;
- }
- }
-
-
- // Delete addresses with 0 valid-time
- ia_na = odhcp6c_get_state(STATE_IA_NA, &ia_na_len);
- ia_end = ia_na + ia_na_len;
- dhcpv6_for_each_option(ia_na, ia_end, otype, olen, odata) {
- struct dhcpv6_ia_addr *p = (void*)&odata[-4];
- while (!p->valid) {
- ia_end = ia_na + odhcp6c_remove_state(STATE_IA_NA,
- (uint8_t*)p - ia_na, olen + 4);
- have_update = true;
- }
- }
-
- return have_update;
+ return true;
}
-static time_t dhcpv6_parse_ia(void *opt, void *end)
+static uint32_t dhcpv6_parse_ia(void *opt, void *end)
{
uint32_t timeout = UINT32_MAX; // Minimum timeout
- uint16_t otype, olen, stype, slen;
- uint8_t *odata, *sdata;
+ uint16_t otype, olen;
+ uint8_t *odata;
+
+ struct odhcp6c_entry entry = {IN6ADDR_ANY_INIT,
+ 0, 0, IN6ADDR_ANY_INIT, 0, 0};
// Update address IA
dhcpv6_for_each_option(opt, end, otype, olen, odata) {
if (olen + 4U < sizeof(*prefix))
continue;
- olen = sizeof(*prefix); // Normalize length
- uint32_t valid = ntohl(prefix->valid);
- uint32_t pref = ntohl(prefix->preferred);
+ entry.valid = ntohl(prefix->valid);
+ entry.preferred = ntohl(prefix->preferred);
- if (pref > valid)
+ if (entry.preferred > entry.valid)
continue;
- // Search matching IA
- struct dhcpv6_ia_prefix *local = NULL;
- size_t pd_len;
- uint8_t *pd = odhcp6c_get_state(STATE_IA_PD, &pd_len);
- dhcpv6_for_each_option(pd, pd + pd_len,
- stype, slen, sdata)
- if (!memcmp(sdata + 8, odata + 8,
- sizeof(local->addr) + 1))
- local = (void*)&sdata[-4];
-
- if (local) { // Already know that IA
- local->preferred = prefix->preferred;
- local->valid = prefix->valid;
- } else { // New IA
- odhcp6c_add_state(STATE_IA_PD, prefix, olen);
- }
+ entry.length = prefix->prefix;
+ entry.target = prefix->addr;
- if (timeout > valid)
- timeout = valid;
+ odhcp6c_update_entry(STATE_IA_PD, &entry);
} else if (otype == DHCPV6_OPT_IA_ADDR) {
struct dhcpv6_ia_addr *addr = (void*)&odata[-4];
if (olen + 4U < sizeof(*addr))
continue;
- olen = sizeof(*addr); // Normalize length
- uint32_t pref = ntohl(addr->preferred);
- uint32_t valid = ntohl(addr->valid);
+ entry.preferred = ntohl(addr->preferred);
+ entry.valid = ntohl(addr->valid);
- if (pref > valid)
+ if (entry.preferred > entry.valid)
continue;
- // Search matching IA
- struct dhcpv6_ia_addr *local = NULL;
- size_t na_len;
- uint8_t *na = odhcp6c_get_state(STATE_IA_NA, &na_len);
- dhcpv6_for_each_option(na, na + na_len,
- stype, slen, sdata)
- if (!memcmp(sdata, odata, sizeof(local->addr)))
- local = (void*)&sdata[-4];
-
-
- if (local) { // Already know that IA
- local->preferred = addr->preferred;
- local->valid = addr->valid;
- } else { // New IA
- odhcp6c_add_state(STATE_IA_NA, addr, olen);
- }
-
+ entry.length = 128;
+ entry.target = addr->addr;
- if (timeout > valid)
- timeout = valid;
-
- if (set_rtnetlink_addr(ifindex, &addr->addr,
- pref, valid) == -EADDRNOTAVAIL) {
- dhcpv6_request(DHCPV6_MSG_DECLINE);
- raise(SIGUSR2);
- }
+ odhcp6c_update_entry(STATE_IA_NA, &entry);
}
+
+ if (entry.valid > 0 && timeout > entry.valid)
+ timeout = entry.valid;
}
return timeout;
projects / odhcp6c.git / blobdiff