// Reconfigure key
static uint8_t reconf_key[16];
+// client options
+static unsigned int client_options = 0;
-int init_dhcpv6(const char *ifname, int request_pd, int sol_timeout)
+
+int init_dhcpv6(const char *ifname, unsigned int options, int sol_timeout)
{
- request_prefix = request_pd;
+ client_options = options;
dhcpv6_retx[DHCPV6_MSG_SOLICIT].max_timeo = sol_timeout;
sock = socket(AF_INET6, SOCK_DGRAM | SOCK_CLOEXEC, IPPROTO_UDP);
}
// Create ORO
- uint16_t oro[] = {
+ if (!(client_options & DHCPV6_STRICT_OPTIONS)) {
+ uint16_t oro[] = {
htons(DHCPV6_OPT_SIP_SERVER_D),
htons(DHCPV6_OPT_SIP_SERVER_A),
htons(DHCPV6_OPT_DNS_SERVERS),
htons(DHCPV6_OPT_DNS_DOMAIN),
+ htons(DHCPV6_OPT_SNTP_SERVERS),
htons(DHCPV6_OPT_NTP_SERVER),
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));
+ };
+ odhcp6c_add_state(STATE_ORO, oro, sizeof(oro));
+ }
// Configure IPv6-options
int val = 1;
pd_mode = pd;
}
-
static void dhcpv6_send(enum dhcpv6_msg type, uint8_t trid[3], uint32_t ecs)
{
// Build FQDN
// Build IA_PDs
size_t ia_pd_entries, ia_pd_len = 0;
- 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),
- 1, 0, 0
- };
+ uint8_t *ia_pd;
+ if (type == DHCPV6_MSG_SOLICIT) {
+ odhcp6c_clear_state(STATE_IA_PD);
+ size_t n_prefixes;
+ struct odhcp6c_request_prefix *request_prefixes = odhcp6c_get_state(STATE_IA_PD_INIT, &n_prefixes);
+ n_prefixes /= sizeof(struct odhcp6c_request_prefix);
+
+ ia_pd = alloca(n_prefixes * (sizeof(struct dhcpv6_ia_hdr) + sizeof(struct dhcpv6_ia_prefix)));
+
+ for (size_t i = 0; i < n_prefixes; i++) {
+ struct dhcpv6_ia_hdr hdr_ia_pd = {
+ htons(DHCPV6_OPT_IA_PD),
+ htons(sizeof(hdr_ia_pd) - 4 + sizeof(struct dhcpv6_ia_prefix)),
+ request_prefixes[i].iaid, 0, 0
+ };
+ struct dhcpv6_ia_prefix pref = {
+ .type = htons(DHCPV6_OPT_IA_PREFIX),
+ .len = htons(25), .prefix = request_prefixes[i].length
+ };
+ memcpy(ia_pd + ia_pd_len, &hdr_ia_pd, sizeof(hdr_ia_pd));
+ ia_pd_len += sizeof(hdr_ia_pd);
+ memcpy(ia_pd + ia_pd_len, &pref, sizeof(pref));
+ ia_pd_len += sizeof(pref);
+ }
+ } else {
+ struct odhcp6c_entry *e = odhcp6c_get_state(STATE_IA_PD, &ia_pd_entries);
+ ia_pd_entries /= sizeof(*e);
+
+ // we're too lazy to count our distinct IAIDs,
+ // so just allocate maximally needed space
+ ia_pd = alloca(ia_pd_entries * (sizeof(struct dhcpv6_ia_prefix) + 10 +
+ sizeof(struct dhcpv6_ia_hdr)));
+
+ for (size_t i = 0; i < ia_pd_entries; ++i) {
+ uint32_t iaid = e[i].iaid;
+
+ // check if this is an unprocessed IAID and skip if not.
+ int new_iaid = 1;
+ for (int j = i-1; j >= 0; j--) {
+ if (e[j].iaid == iaid) {
+ new_iaid = 0;
+ break;
+ }
+ }
- uint8_t *ia_pd = alloca(ia_pd_entries * (sizeof(struct dhcpv6_ia_prefix) + 10));
- for (size_t i = 0; i < ia_pd_entries; ++i) {
- uint8_t ex_len = 0;
- if (e[i].priority > 0)
- ex_len = ((e[i].priority - e[i].length - 1) / 8) + 6;
+ if (!new_iaid)
+ continue;
- struct dhcpv6_ia_prefix p = {
- .type = htons(DHCPV6_OPT_IA_PREFIX),
- .len = htons(sizeof(p) - 4U + ex_len),
- .prefix = e[i].length,
- .addr = e[i].target
- };
+ // construct header
+ struct dhcpv6_ia_hdr hdr_ia_pd = {
+ htons(DHCPV6_OPT_IA_PD),
+ htons(sizeof(hdr_ia_pd) - 4),
+ iaid, 0, 0
+ };
- memcpy(ia_pd + ia_pd_len, &p, sizeof(p));
- ia_pd_len += sizeof(p);
+ memcpy(ia_pd + ia_pd_len, &hdr_ia_pd, sizeof(hdr_ia_pd));
+ struct dhcpv6_ia_hdr *hdr = (struct dhcpv6_ia_hdr *) (ia_pd + ia_pd_len);
+ ia_pd_len += sizeof(hdr_ia_pd);
- if (ex_len) {
- ia_pd[ia_pd_len++] = 0;
- ia_pd[ia_pd_len++] = DHCPV6_OPT_PD_EXCLUDE;
- ia_pd[ia_pd_len++] = 0;
- ia_pd[ia_pd_len++] = ex_len - 4;
- ia_pd[ia_pd_len++] = e[i].priority;
+ for (size_t j = i; j < ia_pd_entries; j++) {
+ if (e[j].iaid != iaid)
+ continue;
- uint32_t excl = ntohl(e[i].router.s6_addr32[1]);
- excl >>= (64 - e[i].priority);
- excl <<= 8 - ((e[i].priority - e[i].length) % 8);
+ uint8_t ex_len = 0;
+ if (e[j].priority > 0)
+ ex_len = ((e[j].priority - e[j].length - 1) / 8) + 6;
+
+ struct dhcpv6_ia_prefix p = {
+ .type = htons(DHCPV6_OPT_IA_PREFIX),
+ .len = htons(sizeof(p) - 4U + ex_len),
+ .prefix = e[j].length,
+ .addr = e[j].target
+ };
+
+ memcpy(ia_pd + ia_pd_len, &p, sizeof(p));
+ ia_pd_len += sizeof(p);
+
+ if (ex_len) {
+ ia_pd[ia_pd_len++] = 0;
+ ia_pd[ia_pd_len++] = DHCPV6_OPT_PD_EXCLUDE;
+ ia_pd[ia_pd_len++] = 0;
+ ia_pd[ia_pd_len++] = ex_len - 4;
+ ia_pd[ia_pd_len++] = e[j].priority;
+
+ uint32_t excl = ntohl(e[j].router.s6_addr32[1]);
+ excl >>= (64 - e[j].priority);
+ excl <<= 8 - ((e[j].priority - e[j].length) % 8);
+
+ for (size_t i = ex_len - 5; i > 0; --i, excl >>= 8)
+ ia_pd[ia_pd_len + i] = excl & 0xff;
+ ia_pd_len += ex_len - 5;
+ }
- for (size_t i = ex_len - 5; i > 0; --i, excl >>= 8)
- ia_pd[ia_pd_len + i] = excl & 0xff;
- ia_pd_len += ex_len - 5;
+ hdr->len = htons(ntohs(hdr->len) + ntohs(p.len) + 4U);
+ }
}
}
- struct dhcpv6_ia_prefix pref = {
- .type = htons(DHCPV6_OPT_IA_PREFIX),
- .len = htons(25), .prefix = request_prefix
- };
- if (request_prefix > 0 && ia_pd_len == 0 && type == DHCPV6_MSG_SOLICIT) {
- ia_pd = (uint8_t*)&pref;
- ia_pd_len = sizeof(pref);
- }
- hdr_ia_pd.len = htons(ntohs(hdr_ia_pd.len) + ia_pd_len);
+ if (ia_pd_entries > 0)
+ request_prefix = 1;
// Build IA_NAs
size_t ia_na_entries, ia_na_len = 0;
void *ia_na = NULL;
- e = odhcp6c_get_state(STATE_IA_NA, &ia_na_entries);
+ struct odhcp6c_entry *e = odhcp6c_get_state(STATE_IA_NA, &ia_na_entries);
ia_na_entries /= sizeof(*e);
struct dhcpv6_ia_hdr hdr_ia_na = {
// Request Information Refresh
uint16_t oro_refresh = htons(DHCPV6_OPT_INFO_REFRESH);
+ // Build vendor-class option
+ size_t vendor_class_len;
+ struct dhcpv6_vendorclass *vendor_class = odhcp6c_get_state(STATE_VENDORCLASS, &vendor_class_len);
+
+ struct {
+ uint16_t type;
+ uint16_t length;
+ } vendor_class_hdr = {htons(DHCPV6_OPT_VENDOR_CLASS), htons(vendor_class_len)};
+
// Prepare Header
size_t oro_len;
void *oro = odhcp6c_get_state(STATE_ORO, &oro_len);
{&oro_refresh, 0},
{cl_id, cl_id_len},
{srv_id, srv_id_len},
+ {&vendor_class_hdr, vendor_class_len ? sizeof(vendor_class_hdr) : 0},
+ {vendor_class, vendor_class_len},
{&reconf_accept, sizeof(reconf_accept)},
{&fqdn, fqdn_len},
{&hdr_ia_na, sizeof(hdr_ia_na)},
{ia_na, ia_na_len},
- {&hdr_ia_pd, sizeof(hdr_ia_pd)},
{ia_pd, ia_pd_len},
};
size_t cnt = ARRAY_SIZE(iov);
if (type == DHCPV6_MSG_INFO_REQ) {
- cnt = 5;
+ cnt = 7;
iov[2].iov_len = sizeof(oro_refresh);
hdr.oro_len = htons(oro_len + sizeof(oro_refresh));
} else if (!request_prefix) {
- cnt = 9;
+ cnt = 11;
}
// Disable IAs if not used
if (type != DHCPV6_MSG_SOLICIT) {
- iov[5].iov_len = 0;
+ iov[7].iov_len = 0;
if (ia_na_len == 0)
- iov[7].iov_len = 0;
- if (ia_pd_len == 0)
iov[9].iov_len = 0;
}
if (na_mode == IA_MODE_NONE)
+ iov[9].iov_len = 0;
+
+ if (!(client_options & DHCPV6_ACCEPT_RECONFIGURE))
iov[7].iov_len = 0;
+ if (!(client_options & DHCPV6_CLIENT_FQDN))
+ iov[8].iov_len = 0;
+
struct sockaddr_in6 srv = {AF_INET6, htons(DHCPV6_SERVER_PORT),
0, ALL_DHCPV6_RELAYS, ifindex};
struct msghdr msg = {&srv, sizeof(srv), iov, cnt, NULL, 0, 0};
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_NTP_IP);
+ odhcp6c_clear_state(STATE_NTP_FQDN);
odhcp6c_clear_state(STATE_SIP_IP);
odhcp6c_clear_state(STATE_SIP_FQDN);
odhcp6c_clear_state(STATE_AFTR_NAME);
struct dhcpv6_ia_hdr *ia_hdr = (void*)(&odata[-4]);
// Test ID
- if (ia_hdr->iaid != 1)
+ if (ia_hdr->iaid != 1 && otype == DHCPV6_OPT_IA_NA)
continue;
uint16_t code = DHCPV6_Success;
odhcp6c_add_state(STATE_DNS, odata, olen);
} else if (otype == DHCPV6_OPT_DNS_DOMAIN) {
odhcp6c_add_state(STATE_SEARCH, odata, olen);
+ } else if (otype == DHCPV6_OPT_SNTP_SERVERS) {
+ if (olen % 16 == 0)
+ odhcp6c_add_state(STATE_SNTP_IP, odata, olen);
} else if (otype == DHCPV6_OPT_NTP_SERVER) {
uint16_t stype, slen;
uint8_t *sdata;
stype, slen, sdata) {
if (slen == 16 && (stype == NTP_MC_ADDR ||
stype == NTP_SRV_ADDR))
- odhcp6c_add_state(STATE_SNTP_IP,
+ odhcp6c_add_state(STATE_NTP_IP,
sdata, slen);
else if (slen > 0 && stype == NTP_SRV_FQDN)
- odhcp6c_add_state(STATE_SNTP_FQDN,
+ odhcp6c_add_state(STATE_NTP_FQDN,
sdata, slen);
}
} else if (otype == DHCPV6_OPT_SIP_SERVER_A) {
// Update address IA
dhcpv6_for_each_option(&ia_hdr[1], end, otype, olen, odata) {
struct odhcp6c_entry entry = {IN6ADDR_ANY_INIT, 0, 0,
- IN6ADDR_ANY_INIT, 0, 0, 0, 0, 0};
+ IN6ADDR_ANY_INIT, 0, 0, 0, 0, 0, 0};
+
+ entry.iaid = ia_hdr->iaid;
if (otype == DHCPV6_OPT_IA_PREFIX) {
struct dhcpv6_ia_prefix *prefix = (void*)&odata[-4];