#include <unistd.h>
#include <syslog.h>
#include <stdbool.h>
+#include <ctype.h>
#include <sys/time.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
static unsigned int client_options = 0;
+static uint32_t ntohl_unaligned(const uint8_t *data)
+{
+ uint32_t buf;
+
+ memcpy(&buf, data, sizeof(buf));
+ return ntohl(buf);
+}
+
int init_dhcpv6(const char *ifname, unsigned int options, int sol_timeout)
{
client_options = options;
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)),
+ htons(sizeof(hdr_ia_pd) - 4 +
+ sizeof(struct dhcpv6_ia_prefix) * !!request_prefixes[i].length),
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
+ .len = htons(sizeof(pref) - 4),
+ .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);
+ if (request_prefixes[i].length) {
+ 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);
// Receive rounds
for (; len < 0 && (round_start < round_end);
round_start = odhcp6c_get_milli_time()) {
- uint8_t buf[1536], cmsg_buf[CMSG_SPACE(sizeof(struct in6_pktinfo))];
+ uint8_t buf[1536];
+ uint8_t cmsg_buf[CMSG_SPACE(sizeof(struct in6_pktinfo))]
+ __aligned(__alignof__(struct cmsghdr));
struct iovec iov = {buf, sizeof(buf)};
struct sockaddr_in6 addr;
struct msghdr msg = {.msg_name = &addr, .msg_namelen = sizeof(addr),
if (otype == DHCPV6_OPT_SERVERID && olen <= 130) {
memcpy(cand.duid, odata, olen);
cand.duid_len = olen;
- } else if (otype == DHCPV6_OPT_STATUS && olen >= 2) {
- int error = ((int)odata[0] << 8 | (int)odata[1]);
-
- switch (error) {
- case DHCPV6_NoPrefixAvail:
- // Status code on global level
- cand.preference -= 2000;
- break;
-
- default :
- break;
- }
} else if (otype == DHCPV6_OPT_PREF && olen >= 1 &&
cand.preference >= 0) {
cand.preference = pref = odata[0];
} else if (otype == DHCPV6_OPT_RECONF_ACCEPT) {
cand.wants_reconfigure = true;
} else if (otype == DHCPV6_OPT_SOL_MAX_RT && olen == 4) {
- uint32_t sol_max_rt = ntohl(*((uint32_t *)odata));
+ uint32_t sol_max_rt = ntohl_unaligned(odata);
if (sol_max_rt >= DHCPV6_SOL_MAX_RT_MIN &&
sol_max_rt <= DHCPV6_SOL_MAX_RT_MAX)
cand.sol_max_rt = sol_max_rt;
} else if (otype == DHCPV6_OPT_INF_MAX_RT && olen == 4) {
- uint32_t inf_max_rt = ntohl(*((uint32_t *)odata));
+ uint32_t inf_max_rt = ntohl_unaligned(odata);
if (inf_max_rt >= DHCPV6_INF_MAX_RT_MIN &&
inf_max_rt <= DHCPV6_INF_MAX_RT_MAX)
cand.inf_max_rt = inf_max_rt;
- } else if (otype == DHCPV6_OPT_IA_PD && request_prefix) {
+ } else if (otype == DHCPV6_OPT_IA_PD && request_prefix &&
+ olen >= -4 + sizeof(struct dhcpv6_ia_hdr)) {
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) {
have_pd = p->prefix;
}
}
- } else if (otype == DHCPV6_OPT_IA_NA) {
+ } else if (otype == DHCPV6_OPT_IA_NA &&
+ olen >= -4 + sizeof(struct dhcpv6_ia_hdr)) {
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)
odhcp6c_clear_state(STATE_S46_MAPE);
odhcp6c_clear_state(STATE_S46_LW);
odhcp6c_clear_state(STATE_PASSTHRU);
+ odhcp6c_clear_state(STATE_CUSTOM_OPTS);
// Parse and find all matching IAs
dhcpv6_for_each_option(opt, end, otype, olen, odata) {
} else if (otype == DHCPV6_OPT_SIP_SERVER_D) {
odhcp6c_add_state(STATE_SIP_FQDN, odata, olen);
} else if (otype == DHCPV6_OPT_INFO_REFRESH && olen >= 4) {
- refresh = ntohl(*((uint32_t*)odata));
+ refresh = ntohl_unaligned(odata);
passthru = false;
} else if (otype == DHCPV6_OPT_AUTH) {
if (olen == -4 + sizeof(struct dhcpv6_auth_reconfigure)) {
odhcp6c_add_state(STATE_AFTR_NAME, odata, olen);
passthru = false;
} else if (otype == DHCPV6_OPT_SOL_MAX_RT && olen == 4) {
- uint32_t sol_max_rt = ntohl(*((uint32_t *)odata));
+ uint32_t sol_max_rt = ntohl_unaligned(odata);
if (sol_max_rt >= DHCPV6_SOL_MAX_RT_MIN &&
sol_max_rt <= DHCPV6_SOL_MAX_RT_MAX)
dhcpv6_retx[DHCPV6_MSG_SOLICIT].max_timeo = sol_max_rt;
passthru = false;
} else if (otype == DHCPV6_OPT_INF_MAX_RT && olen == 4) {
- uint32_t inf_max_rt = ntohl(*((uint32_t *)odata));
+ uint32_t inf_max_rt = ntohl_unaligned(odata);
if (inf_max_rt >= DHCPV6_INF_MAX_RT_MIN &&
inf_max_rt <= DHCPV6_INF_MAX_RT_MAX)
dhcpv6_retx[DHCPV6_MSG_INFO_REQ].max_timeo = inf_max_rt;
if (elen > 64)
elen = 64;
- if (elen <= 32 || elen <= entry.length) {
+ if (entry.length < 32 || elen <= entry.length) {
ok = false;
continue;
}
static void dhcpv6_log_status_code(const uint16_t code, const char *scope,
- const void *status_msg, const int len)
+ const void *status_msg, int len)
{
- uint8_t buf[len + 3];
+ const char *src = status_msg;
+ char buf[len + 3];
+ char *dst = buf;
- memset(buf, 0, sizeof(buf));
if (len) {
- buf[0] = '(';
- memcpy(&buf[1], status_msg, len);
- buf[len + 1] = ')';
+ *dst++ = '(';
+ while (len--) {
+ *dst = isprint((unsigned char)*src) ? *src : '?';
+ src++;
+ dst++;
+ }
+ *dst++ = ')';
}
+ *dst = 0;
syslog(LOG_WARNING, "Server returned %s status %i %s",
scope, code, buf);
}
}
+// Note this always takes ownership of cand->ia_na and cand->ia_pd
static void dhcpv6_add_server_cand(const struct dhcpv6_server_cand *cand)
{
size_t cand_len, i;
break;
}
- odhcp6c_insert_state(STATE_SERVER_CAND, i * sizeof(*c), cand, sizeof(*cand));
+ if (odhcp6c_insert_state(STATE_SERVER_CAND, i * sizeof(*c), cand, sizeof(*cand))) {
+ free(cand->ia_na);
+ free(cand->ia_pd);
+ }
}
static void dhcpv6_clear_all_server_cand(void)