static struct dhcpv6_retx dhcpv6_retx[_DHCPV6_MSG_MAX] = {
[DHCPV6_MSG_UNKNOWN] = {false, 1, 120, "<POLL>",
dhcpv6_handle_reconfigure, NULL},
- [DHCPV6_MSG_SOLICIT] = {true, 1, 3600, "SOLICIT",
+ [DHCPV6_MSG_SOLICIT] = {true, 1, 120, "SOLICIT",
dhcpv6_handle_advert, dhcpv6_commit_advert},
- [DHCPV6_MSG_REQUEST] = {true, 30, 10, "REQUEST",
+ [DHCPV6_MSG_REQUEST] = {true, 1, 30, "REQUEST",
dhcpv6_handle_reply, NULL},
[DHCPV6_MSG_RENEW] = {false, 10, 600, "RENEW",
dhcpv6_handle_reply, NULL},
// IA states
static int request_prefix = -1;
-static enum odhcp6c_ia_mode na_mode = IA_MODE_NONE;
+static enum odhcp6c_ia_mode na_mode = IA_MODE_NONE, pd_mode = IA_MODE_NONE;
static bool accept_reconfig = false;
// Reconfigure key
-int init_dhcpv6(const char *ifname, int request_pd)
+int init_dhcpv6(const char *ifname, int request_pd, int sol_timeout)
{
request_prefix = request_pd;
+ dhcpv6_retx[DHCPV6_MSG_SOLICIT].max_timeo = sol_timeout;
sock = socket(AF_INET6, SOCK_DGRAM | SOCK_CLOEXEC, IPPROTO_UDP);
htons(DHCPV6_OPT_DNS_SERVERS),
htons(DHCPV6_OPT_DNS_DOMAIN),
htons(DHCPV6_OPT_NTP_SERVER),
+ htons(DHCPV6_OPT_SIP_SERVER_A),
htons(DHCPV6_OPT_AFTR_NAME),
htons(DHCPV6_OPT_PD_EXCLUDE),
+#ifdef EXT_PREFIX_CLASS
+ htons(DHCPV6_OPT_PREFIX_CLASS),
+#endif
};
odhcp6c_add_state(STATE_ORO, oro, sizeof(oro));
}
-void dhcpv6_set_ia_na_mode(enum odhcp6c_ia_mode mode)
+void dhcpv6_set_ia_mode(enum odhcp6c_ia_mode na, enum odhcp6c_ia_mode pd)
{
- na_mode = mode;
+ na_mode = na;
+ pd_mode = pd;
}
.type = htons(DHCPV6_OPT_IA_PREFIX),
.len = htons(25), .prefix = request_prefix
};
- if (request_prefix > 0 && ia_pd_len == 0 &&
- (type == DHCPV6_MSG_SOLICIT ||
- type == DHCPV6_MSG_REQUEST)) {
+ if (request_prefix > 0 && ia_pd_len == 0 && type == DHCPV6_MSG_SOLICIT) {
ia_pd = (uint8_t*)&pref;
ia_pd_len = sizeof(pref);
}
}
// Disable IAs if not used
- if (type != DHCPV6_MSG_REQUEST && type != DHCPV6_MSG_SOLICIT) {
+ if (type != DHCPV6_MSG_SOLICIT) {
iov[5].iov_len = 0;
if (ia_na_len == 0)
iov[7].iov_len = 0;
{
int random;
odhcp6c_random(&random, sizeof(random));
- return (time * (random % 1000)) / 10000;
+ return (time * ((int64_t)random % 1000LL)) / 10000LL;
}
int dhcpv6_request(enum dhcpv6_msg type)
{
uint8_t buf[1536];
- uint32_t timeout = UINT32_MAX;
+ uint64_t timeout = UINT32_MAX;
struct dhcpv6_retx *retx = &dhcpv6_retx[type];
if (retx->delay) {
nanosleep(&ts, NULL);
}
- if (type == DHCPV6_MSG_RELEASE || type == DHCPV6_MSG_DECLINE)
+ if (type == DHCPV6_MSG_REQUEST)
+ timeout = 60;
+ else if (type == DHCPV6_MSG_RELEASE || type == DHCPV6_MSG_DECLINE)
timeout = 3;
else if (type == DHCPV6_MSG_UNKNOWN)
timeout = t1;
if (timeout == 0)
return -1;
- syslog(LOG_NOTICE, "Sending %s (timeout %us)", retx->name, timeout);
+ syslog(LOG_NOTICE, "Sending %s (timeout %us)", retx->name, (unsigned)timeout);
uint64_t start = odhcp6c_get_milli_time(), round_start = start, elapsed;
len = retx->handler_reply(
type, opt, opt_end);
- if (round_end - round_start > 1000)
+ if (len > 0 && round_end - round_start > 1000)
round_end = 1000 + round_start;
}
}
// Collect all advertised servers
-static int dhcpv6_handle_advert(_unused enum dhcpv6_msg orig,
+static int dhcpv6_handle_advert(enum dhcpv6_msg orig,
const void *opt, const void *end)
{
uint16_t olen, otype;
uint8_t *odata;
- struct dhcpv6_server_cand cand = {false, false, 0, 0, {0}};
+ struct dhcpv6_server_cand cand = {false, false, 0, 0, {0}, NULL, NULL, 0, 0};
+ bool have_na = false;
+ int have_pd = 0;
dhcpv6_for_each_option(opt, end, otype, olen, odata) {
+ if (orig == DHCPV6_MSG_SOLICIT &&
+ (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]);
+ dhcpv6_parse_ia(&ia_hdr[1], odata + olen);
+ }
+
if (otype == DHCPV6_OPT_SERVERID && olen <= 130) {
memcpy(cand.duid, odata, olen);
cand.duid_len = olen;
- } else if (otype == DHCPV6_OPT_STATUS && olen >= 2 && !odata[0]
- && odata[1] == DHCPV6_NoAddrsAvail) {
- if (na_mode == IA_MODE_FORCE) {
- return -1;
- } else {
- cand.has_noaddravail = true;
- cand.preference -= 1000;
- }
} else if (otype == DHCPV6_OPT_STATUS && olen >= 2 && !odata[0]
&& odata[1] == DHCPV6_NoPrefixAvail) {
cand.preference -= 2000;
struct dhcpv6_ia_hdr *h = (struct dhcpv6_ia_hdr*)&odata[-4];
uint8_t *oend = odata + olen, *d;
dhcpv6_for_each_option(&h[1], oend, otype, olen, d) {
- if (otype == DHCPV6_OPT_IA_PREFIX)
- cand.preference += 2000;
- else if (otype == DHCPV6_OPT_STATUS &&
- olen >= 2 && d[0] == 0 &&
- d[1] == DHCPV6_NoPrefixAvail)
- cand.preference -= 2000;
+ if (otype == DHCPV6_OPT_IA_PREFIX && (olen + 4) >=
+ (uint16_t)sizeof(struct dhcpv6_ia_prefix)) {
+ struct dhcpv6_ia_prefix *p = (struct dhcpv6_ia_prefix*)&d[-4];
+ have_pd = p->prefix;
+ }
}
+ } else if (otype == DHCPV6_OPT_IA_NA) {
+ struct dhcpv6_ia_hdr *h = (struct dhcpv6_ia_hdr*)&odata[-4];
+ uint8_t *oend = odata + olen, *d;
+ dhcpv6_for_each_option(&h[1], oend, otype, olen, d)
+ if (otype == DHCPV6_OPT_IA_ADDR)
+ have_na = true;
}
}
- if (cand.duid_len > 0)
+ if ((!have_na && na_mode == IA_MODE_FORCE) ||
+ (!have_pd && pd_mode == IA_MODE_FORCE))
+ return -1;
+
+ if (na_mode != IA_MODE_NONE && !have_na) {
+ cand.has_noaddravail = true;
+ cand.preference -= 1000;
+ }
+
+ if (pd_mode != IA_MODE_NONE) {
+ if (have_pd)
+ cand.preference += 2000 + (128 - have_pd);
+ else
+ cand.preference -= 2000;
+ }
+
+ if (cand.duid_len > 0) {
+ cand.ia_na = odhcp6c_move_state(STATE_IA_NA, &cand.ia_na_len);
+ cand.ia_pd = odhcp6c_move_state(STATE_IA_PD, &cand.ia_pd_len);
odhcp6c_add_state(STATE_SERVER_CAND, &cand, sizeof(cand));
+ }
+
+ if (orig == DHCPV6_MSG_SOLICIT) {
+ odhcp6c_clear_state(STATE_IA_NA);
+ odhcp6c_clear_state(STATE_IA_PD);
+ }
return -1;
}
odhcp6c_add_state(STATE_SERVER_ID, hdr, sizeof(hdr));
odhcp6c_add_state(STATE_SERVER_ID, c->duid, c->duid_len);
accept_reconfig = c->wants_reconfigure;
+ odhcp6c_add_state(STATE_IA_NA, c->ia_na, c->ia_na_len);
+ odhcp6c_add_state(STATE_IA_PD, c->ia_pd, c->ia_pd_len);
}
+ for (size_t i = 0; i < cand_len / sizeof(*c); ++i) {
+ free(cand[i].ia_na);
+ free(cand[i].ia_pd);
+ }
odhcp6c_clear_state(STATE_SERVER_CAND);
if (!c)
t1 = t2 = t3 = UINT32_MAX;
}
+ if (orig == DHCPV6_MSG_REQUEST) {
+ // Delete NA and PD we have in the state from the Advert
+ odhcp6c_clear_state(STATE_IA_NA);
+ odhcp6c_clear_state(STATE_IA_PD);
+ }
+
if (opt) {
odhcp6c_clear_state(STATE_DNS);
odhcp6c_clear_state(STATE_SEARCH);
if (ia_hdr->iaid != 1 || l_t2 < l_t1)
continue;
- bool error = false;
+ int error = 0;
uint16_t stype, slen;
uint8_t *sdata;
// Test status and bail if error
dhcpv6_for_each_option(&ia_hdr[1], odata + olen,
stype, slen, sdata)
- if (stype == DHCPV6_OPT_STATUS && slen >= 2 &&
- (sdata[0] || sdata[1]))
- error = true;
-
- if (error)
- continue;
+ if (stype == DHCPV6_OPT_STATUS && slen >= 2)
+ error = ((int)sdata[0]) << 8 | ((int)sdata[1]);
+
+ if (error) {
+ syslog(LOG_WARNING, "Server returned IAID status %i!", error);
+ if (error != 2)
+ raise(SIGUSR2);
+ break;
+ }
uint32_t n = dhcpv6_parse_ia(&ia_hdr[1], odata + olen);
}
}
+ if (t1 == UINT32_MAX)
+ t1 = 300;
+
+ if (t2 == UINT32_MAX)
+ t2 = 600;
+
+ if (t3 == UINT32_MAX)
+ t3 = 3600;
+
return true;
}
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) {
+ struct odhcp6c_entry entry = {IN6ADDR_ANY_INIT, 0, 0,
+ IN6ADDR_ANY_INIT, 0, 0, 0};
+
if (otype == DHCPV6_OPT_IA_PREFIX) {
struct dhcpv6_ia_prefix *prefix = (void*)&odata[-4];
if (olen + 4U < sizeof(*prefix))
entry.length = prefix->prefix;
entry.target = prefix->addr;
+ uint16_t stype, slen;
+ uint8_t *sdata;
+
+#ifdef EXT_PREFIX_CLASS
+ // Find prefix class, if any
+ dhcpv6_for_each_option(&prefix[1], odata + olen,
+ stype, slen, sdata)
+ if (stype == DHCPV6_OPT_PREFIX_CLASS && slen == 2)
+ entry.class = sdata[0] << 8 | sdata[1];
+#endif
// Parse PD-exclude
bool ok = true;
- uint16_t stype, slen;
- uint8_t *sdata;
dhcpv6_for_each_option(odata + sizeof(*prefix) - 4U,
odata + olen, stype, slen, sdata) {
if (stype != DHCPV6_OPT_PD_EXCLUDE || slen < 2)
entry.length = 128;
entry.target = addr->addr;
+#ifdef EXT_PREFIX_CLASS
+ uint16_t stype, slen;
+ uint8_t *sdata;
+ // Find prefix class, if any
+ dhcpv6_for_each_option(&addr[1], odata + olen,
+ stype, slen, sdata)
+ if (stype == DHCPV6_OPT_PREFIX_CLASS && slen == 2)
+ entry.class = sdata[0] << 8 | sdata[1];
+#endif
+
odhcp6c_update_entry(STATE_IA_NA, &entry);
}
-
if (entry.valid > 0 && timeout > entry.valid)
timeout = entry.valid;
}
projects / odhcp6c.git / blobdiff