#define START_DEFAULT 100
#define LIMIT_DEFAULT 150
+#define HOSTID_LEN_MIN 12
+#define HOSTID_LEN_MAX 64
+#define HOSTID_LEN_DEFAULT HOSTID_LEN_MIN
+
+#define OAF_DHCPV6 (OAF_DHCPV6_NA | OAF_DHCPV6_PD)
+
enum {
IFACE_ATTR_INTERFACE,
IFACE_ATTR_IFNAME,
IFACE_ATTR_NDP,
IFACE_ATTR_ROUTER,
IFACE_ATTR_DNS,
+ IFACE_ATTR_DNS_SERVICE,
IFACE_ATTR_DOMAIN,
IFACE_ATTR_FILTER_CLASS,
IFACE_ATTR_DHCPV4_FORCERECONF,
IFACE_ATTR_DHCPV6_ASSIGNALL,
IFACE_ATTR_DHCPV6_PD,
IFACE_ATTR_DHCPV6_NA,
+ IFACE_ATTR_DHCPV6_HOSTID_LEN,
IFACE_ATTR_RA_DEFAULT,
IFACE_ATTR_RA_MANAGEMENT,
+ IFACE_ATTR_RA_FLAGS,
+ IFACE_ATTR_RA_SLAAC,
IFACE_ATTR_RA_OFFLINK,
IFACE_ATTR_RA_PREFERENCE,
IFACE_ATTR_RA_ADVROUTER,
IFACE_ATTR_NDPROXY_ROUTING,
IFACE_ATTR_NDPROXY_SLAVE,
IFACE_ATTR_PREFIX_FILTER,
+ IFACE_ATTR_PREFERRED_LIFETIME,
+ IFACE_ATTR_NTP,
IFACE_ATTR_MAX
};
[IFACE_ATTR_NDP] = { .name = "ndp", .type = BLOBMSG_TYPE_STRING },
[IFACE_ATTR_ROUTER] = { .name = "router", .type = BLOBMSG_TYPE_ARRAY },
[IFACE_ATTR_DNS] = { .name = "dns", .type = BLOBMSG_TYPE_ARRAY },
+ [IFACE_ATTR_DNS_SERVICE] = { .name = "dns_service", .type = BLOBMSG_TYPE_BOOL },
[IFACE_ATTR_DOMAIN] = { .name = "domain", .type = BLOBMSG_TYPE_ARRAY },
[IFACE_ATTR_FILTER_CLASS] = { .name = "filter_class", .type = BLOBMSG_TYPE_STRING },
[IFACE_ATTR_DHCPV4_FORCERECONF] = { .name = "dhcpv4_forcereconf", .type = BLOBMSG_TYPE_BOOL },
[IFACE_ATTR_DHCPV6_ASSIGNALL] = { .name ="dhcpv6_assignall", .type = BLOBMSG_TYPE_BOOL },
[IFACE_ATTR_DHCPV6_PD] = { .name = "dhcpv6_pd", .type = BLOBMSG_TYPE_BOOL },
[IFACE_ATTR_DHCPV6_NA] = { .name = "dhcpv6_na", .type = BLOBMSG_TYPE_BOOL },
+ [IFACE_ATTR_DHCPV6_HOSTID_LEN] = { .name = "dhcpv6_hostidlength", .type = BLOBMSG_TYPE_INT32 },
[IFACE_ATTR_PD_MANAGER] = { .name = "pd_manager", .type = BLOBMSG_TYPE_STRING },
[IFACE_ATTR_PD_CER] = { .name = "pd_cer", .type = BLOBMSG_TYPE_STRING },
[IFACE_ATTR_RA_DEFAULT] = { .name = "ra_default", .type = BLOBMSG_TYPE_INT32 },
[IFACE_ATTR_RA_MANAGEMENT] = { .name = "ra_management", .type = BLOBMSG_TYPE_INT32 },
+ [IFACE_ATTR_RA_FLAGS] = { .name = "ra_flags", . type = BLOBMSG_TYPE_ARRAY },
+ [IFACE_ATTR_RA_SLAAC] = { .name = "ra_slaac", .type = BLOBMSG_TYPE_BOOL },
[IFACE_ATTR_RA_OFFLINK] = { .name = "ra_offlink", .type = BLOBMSG_TYPE_BOOL },
[IFACE_ATTR_RA_PREFERENCE] = { .name = "ra_preference", .type = BLOBMSG_TYPE_STRING },
[IFACE_ATTR_RA_ADVROUTER] = { .name = "ra_advrouter", .type = BLOBMSG_TYPE_BOOL },
[IFACE_ATTR_NDPROXY_ROUTING] = { .name = "ndproxy_routing", .type = BLOBMSG_TYPE_BOOL },
[IFACE_ATTR_NDPROXY_SLAVE] = { .name = "ndproxy_slave", .type = BLOBMSG_TYPE_BOOL },
[IFACE_ATTR_PREFIX_FILTER] = { .name = "prefix_filter", .type = BLOBMSG_TYPE_STRING },
+ [IFACE_ATTR_PREFERRED_LIFETIME] = { .name = "preferred_lifetime", .type = BLOBMSG_TYPE_STRING },
+ [IFACE_ATTR_NTP] = { .name = "ntp", .type = BLOBMSG_TYPE_ARRAY },
};
static const struct uci_blob_param_info iface_attr_info[IFACE_ATTR_MAX] = {
.info = iface_attr_info,
};
-enum {
- LEASE_ATTR_IP,
- LEASE_ATTR_MAC,
- LEASE_ATTR_DUID,
- LEASE_ATTR_HOSTID,
- LEASE_ATTR_LEASETIME,
- LEASE_ATTR_NAME,
- LEASE_ATTR_MAX
-};
-
-static const struct blobmsg_policy lease_attrs[LEASE_ATTR_MAX] = {
+const struct blobmsg_policy lease_attrs[LEASE_ATTR_MAX] = {
[LEASE_ATTR_IP] = { .name = "ip", .type = BLOBMSG_TYPE_STRING },
[LEASE_ATTR_MAC] = { .name = "mac", .type = BLOBMSG_TYPE_STRING },
[LEASE_ATTR_DUID] = { .name = "duid", .type = BLOBMSG_TYPE_STRING },
.params = odhcpd_attrs,
};
-static int mkdir_p(char *dir, mode_t mask)
-{
- char *l = strrchr(dir, '/');
- int ret;
-
- if (!l)
- return 0;
-
- *l = '\0';
-
- if (mkdir_p(dir, mask))
- return -1;
-
- *l = '/';
-
- ret = mkdir(dir, mask);
- if (ret && errno == EEXIST)
- return 0;
-
- if (ret)
- syslog(LOG_ERR, "mkdir(%s, %d) failed: %m\n", dir, mask);
-
- return ret;
-}
+static const struct { const char *name; uint8_t flag; } ra_flags[] = {
+ { .name = "managed-config", .flag = ND_RA_FLAG_MANAGED },
+ { .name = "other-config", .flag = ND_RA_FLAG_OTHER },
+ { .name = "home-agent", .flag = ND_RA_FLAG_HOME_AGENT },
+ { .name = "none", . flag = 0 },
+ { .name = NULL, },
+};
static void set_interface_defaults(struct interface *iface)
{
iface->ra = MODE_DISABLED;
iface->ndp = MODE_DISABLED;
iface->learn_routes = 1;
- iface->dhcpv4_leasetime = 43200;
+ iface->dhcp_leasetime = 43200;
+ iface->preferred_lifetime = 43200;
iface->dhcpv4_start.s_addr = htonl(START_DEFAULT);
iface->dhcpv4_end.s_addr = htonl(START_DEFAULT + LIMIT_DEFAULT - 1);
iface->dhcpv6_assignall = true;
iface->dhcpv6_pd = true;
iface->dhcpv6_na = true;
- iface->ra_managed = RA_MANAGED_MFLAG;
+ iface->dhcpv6_hostid_len = HOSTID_LEN_DEFAULT;
+ iface->dns_service = true;
+ iface->ra_flags = ND_RA_FLAG_OTHER;
+ iface->ra_slaac = true;
iface->ra_maxinterval = 600;
iface->ra_mininterval = iface->ra_maxinterval/3;
iface->ra_lifetime = -1;
free(iface->dhcpv4_dns);
free(iface->dhcpv6_raw);
free(iface->filter_class);
+ free(iface->dhcpv4_ntp);
+ free(iface->dhcpv6_ntp);
+ free(iface->dhcpv6_sntp);
memset(&iface->ra, 0, sizeof(*iface) - offsetof(struct interface, ra));
set_interface_defaults(iface);
}
clean_interface(iface);
free(iface->addr4);
free(iface->addr6);
+ free(iface->invalid_addr6);
free(iface->ifname);
free(iface);
}
return -1;
}
+static int parse_ra_flags(uint8_t *flags, struct blob_attr *attr)
+{
+ struct blob_attr *cur;
+ unsigned rem;
+
+ blobmsg_for_each_attr(cur, attr, rem) {
+ int i;
+
+ if (blobmsg_type(cur) != BLOBMSG_TYPE_STRING)
+ continue;
+
+ if (!blobmsg_check_attr(cur, false))
+ continue;
+
+ for (i = 0; ra_flags[i].name; i++) {
+ if (!strcmp(ra_flags[i].name, blobmsg_get_string(cur))) {
+ *flags |= ra_flags[i].flag;
+ break;
+ }
+ }
+
+ if (!ra_flags[i].name)
+ return -1;
+ }
+
+ return 0;
+}
+
static void set_config(struct uci_section *s)
{
struct blob_attr *tb[ODHCPD_ATTR_MAX], *c;
free(l);
}
-static int set_lease(struct uci_section *s)
+
+int set_lease_from_blobmsg(struct blob_attr *ba)
{
struct blob_attr *tb[LEASE_ATTR_MAX], *c;
struct lease *l;
size_t duidlen = 0;
uint8_t *duid;
- blob_buf_init(&b, 0);
- uci_to_blob(&b, s, &lease_attr_list);
- blobmsg_parse(lease_attrs, LEASE_ATTR_MAX, tb, blob_data(b.head), blob_len(b.head));
+ blobmsg_parse(lease_attrs, LEASE_ATTR_MAX, tb, blob_data(ba), blob_len(ba));
if ((c = tb[LEASE_ATTR_DUID]))
duidlen = (blobmsg_data_len(c) - 1) / 2;
if ((c = tb[LEASE_ATTR_HOSTID])) {
errno = 0;
- l->hostid = strtoul(blobmsg_get_string(c), NULL, 16);
+ l->hostid = strtoull(blobmsg_get_string(c), NULL, 16);
if (errno)
goto err;
} else {
return -1;
}
+static int set_lease_from_uci(struct uci_section *s)
+{
+ blob_buf_init(&b, 0);
+ uci_to_blob(&b, s, &lease_attr_list);
+
+ return set_lease_from_blobmsg(b.head);
+}
+
+/* Parse NTP Options for DHCPv6 Address */
+static int parse_ntp_options(uint16_t *dhcpv6_ntp_len, struct in6_addr addr6, uint8_t **dhcpv6_ntp)
+{
+ uint16_t sub_opt = 0, sub_len = htons(IPV6_ADDR_LEN);
+ uint16_t ntp_len = IPV6_ADDR_LEN + 4;
+ uint8_t *ntp = *dhcpv6_ntp;
+ size_t pos = *dhcpv6_ntp_len;
+
+ ntp = realloc(ntp, pos + ntp_len);
+ if (!ntp)
+ return -1;
+
+ *dhcpv6_ntp = ntp;
+
+ if (IN6_IS_ADDR_MULTICAST(&addr6))
+ sub_opt = htons(NTP_SUBOPTION_MC_ADDR);
+ else
+ sub_opt = htons(NTP_SUBOPTION_SRV_ADDR);
+
+ memcpy(ntp + pos, &sub_opt, sizeof(sub_opt));
+ pos += sizeof(sub_opt);
+ memcpy(ntp + pos, &sub_len, sizeof(sub_len));
+ pos += sizeof(sub_len);
+ memcpy(ntp + pos, &addr6, IPV6_ADDR_LEN);
+
+ *dhcpv6_ntp_len += ntp_len;
+
+ return 0;
+}
+
+/* Parse NTP Options for FQDN */
+static int parse_ntp_fqdn(uint16_t *dhcpv6_ntp_len, char *fqdn, uint8_t **dhcpv6_ntp)
+{
+ size_t fqdn_len = strlen(fqdn);
+ uint16_t sub_opt = 0, sub_len = 0, ntp_len = 0;
+ uint8_t *ntp = *dhcpv6_ntp;
+ size_t pos = *dhcpv6_ntp_len;
+ uint8_t buf[256] = {0};
+
+ if (fqdn_len > 0 && fqdn[fqdn_len - 1] == '.')
+ fqdn[fqdn_len - 1] = 0;
+
+ int len = dn_comp(fqdn, buf, sizeof(buf), NULL, NULL);
+ if (len <= 0)
+ return -1;
+
+ ntp_len = len + 4;
+
+ ntp = realloc(ntp, pos + ntp_len);
+ if (!ntp)
+ return -1;
+
+ *dhcpv6_ntp = ntp;
+
+ sub_opt = htons(NTP_SUBOPTION_SRV_FQDN);
+ sub_len = htons(len);
+
+ memcpy(ntp + pos, &sub_opt, sizeof(sub_opt));
+ pos += sizeof(sub_opt);
+ memcpy(ntp + pos, &sub_len, sizeof(sub_len));
+ pos += sizeof(sub_len);
+ memcpy(ntp + pos, buf, len);
+
+ *dhcpv6_ntp_len += ntp_len;
+
+ return 0;
+}
+
int config_parse_interface(void *data, size_t len, const char *name, bool overwrite)
{
struct interface *iface;
struct blob_attr *tb[IFACE_ATTR_MAX], *c;
bool get_addrs = false;
+ int mode;
+ const char *ifname = NULL;
blobmsg_parse(iface_attrs, IFACE_ATTR_MAX, tb, data, len);
get_addrs = overwrite = true;
}
- const char *ifname = NULL;
if (overwrite) {
if ((c = tb[IFACE_ATTR_IFNAME]))
ifname = blobmsg_get_string(c);
if (!iface->ifindex &&
(iface->ifindex = if_nametoindex(iface->ifname)) <= 0)
goto err;
+
+ if ((iface->ifflags = odhcpd_get_flags(iface)) < 0)
+ goto err;
}
if (get_addrs) {
iface->addr4_len = len;
}
+ for (size_t i = 0; i < iface->addr6_len; i++) {
+ struct odhcpd_ipaddr *addr = &iface->addr6[i];
+
+ if (!addr->tentative) {
+ iface->have_link_local = true;
+ break;
+ }
+ }
+
iface->inuse = true;
if ((c = tb[IFACE_ATTR_DYNAMICDHCP]))
if ((c = tb[IFACE_ATTR_LEASETIME])) {
double time = parse_leasetime(c);
- if (time < 0)
- goto err;
- iface->dhcpv4_leasetime = time;
+ if (time >= 0)
+ iface->dhcp_leasetime = time;
+ else
+ syslog(LOG_ERR, "Invalid %s value configured for interface '%s'",
+ iface_attrs[IFACE_ATTR_LEASETIME].name, iface->name);
+
+ }
+
+ if ((c = tb[IFACE_ATTR_PREFERRED_LIFETIME])) {
+ double time = parse_leasetime(c);
+
+ if (time >= 0)
+ iface->preferred_lifetime = time;
+ else
+ syslog(LOG_ERR, "Invalid %s value configured for interface '%s'",
+ iface_attrs[IFACE_ATTR_PREFERRED_LIFETIME].name, iface->name);
+
}
if ((c = tb[IFACE_ATTR_START])) {
}
}
- int mode;
if ((c = tb[IFACE_ATTR_RA])) {
if ((mode = parse_mode(blobmsg_get_string(c))) >= 0) {
iface->ra = mode;
if (iface->ra != MODE_DISABLED)
iface->ignore = false;
} else
- goto err;
+ syslog(LOG_ERR, "Invalid %s mode configured for interface '%s'",
+ iface_attrs[IFACE_ATTR_RA].name, iface->name);
}
if ((c = tb[IFACE_ATTR_DHCPV4])) {
if (iface->dhcpv4 != MODE_DISABLED)
iface->ignore = false;
}
- }
- else
- goto err;
+ } else
+ syslog(LOG_ERR, "Invalid %s mode configured for interface %s",
+ iface_attrs[IFACE_ATTR_DHCPV4].name, iface->name);
}
if ((c = tb[IFACE_ATTR_DHCPV6])) {
if (iface->dhcpv6 != MODE_DISABLED)
iface->ignore = false;
} else
- goto err;
+ syslog(LOG_ERR, "Invalid %s mode configured for interface '%s'",
+ iface_attrs[IFACE_ATTR_DHCPV6].name, iface->name);
}
if ((c = tb[IFACE_ATTR_NDP])) {
if (iface->ndp != MODE_DISABLED)
iface->ignore = false;
} else
- goto err;
+ syslog(LOG_ERR, "Invalid %s mode configured for interface '%s'",
+ iface_attrs[IFACE_ATTR_NDP].name, iface->name);
}
if ((c = tb[IFACE_ATTR_ROUTER])) {
unsigned rem;
blobmsg_for_each_attr(cur, c, rem) {
+ struct in_addr addr4;
+
if (blobmsg_type(cur) != BLOBMSG_TYPE_STRING || !blobmsg_check_attr(cur, false))
continue;
- struct in_addr addr4;
if (inet_pton(AF_INET, blobmsg_get_string(cur), &addr4) == 1) {
iface->dhcpv4_router = realloc(iface->dhcpv4_router,
(++iface->dhcpv4_router_cnt) * sizeof(*iface->dhcpv4_router));
iface->dhcpv4_router[iface->dhcpv4_router_cnt - 1] = addr4;
} else
- goto err;
+ syslog(LOG_ERR, "Invalid %s value configured for interface '%s'",
+ iface_attrs[IFACE_ATTR_ROUTER].name, iface->name);
}
}
iface->always_rewrite_dns = true;
blobmsg_for_each_attr(cur, c, rem) {
+ struct in_addr addr4;
+ struct in6_addr addr6;
+
if (blobmsg_type(cur) != BLOBMSG_TYPE_STRING || !blobmsg_check_attr(cur, false))
continue;
- struct in_addr addr4;
- struct in6_addr addr6;
if (inet_pton(AF_INET, blobmsg_get_string(cur), &addr4) == 1) {
- if (addr4.s_addr == INADDR_ANY)
- goto err;
+ if (addr4.s_addr == INADDR_ANY) {
+ syslog(LOG_ERR, "Invalid %s value configured for interface '%s'",
+ iface_attrs[IFACE_ATTR_DNS].name, iface->name);
+
+ continue;
+ }
iface->dhcpv4_dns = realloc(iface->dhcpv4_dns,
(++iface->dhcpv4_dns_cnt) * sizeof(*iface->dhcpv4_dns));
iface->dhcpv4_dns[iface->dhcpv4_dns_cnt - 1] = addr4;
} else if (inet_pton(AF_INET6, blobmsg_get_string(cur), &addr6) == 1) {
- if (IN6_IS_ADDR_UNSPECIFIED(&addr6))
- goto err;
+ if (IN6_IS_ADDR_UNSPECIFIED(&addr6)) {
+ syslog(LOG_ERR, "Invalid %s value configured for interface '%s'",
+ iface_attrs[IFACE_ATTR_DNS].name, iface->name);
+
+ continue;
+ }
iface->dns = realloc(iface->dns,
(++iface->dns_cnt) * sizeof(*iface->dns));
iface->dns[iface->dns_cnt - 1] = addr6;
} else
- goto err;
+ syslog(LOG_ERR, "Invalid %s value configured for interface '%s'",
+ iface_attrs[IFACE_ATTR_DNS].name, iface->name);
}
}
+ if ((c = tb[IFACE_ATTR_DNS_SERVICE]))
+ iface->dns_service = blobmsg_get_bool(c);
+
if ((c = tb[IFACE_ATTR_DOMAIN])) {
struct blob_attr *cur;
unsigned rem;
blobmsg_for_each_attr(cur, c, rem) {
- if (blobmsg_type(cur) != BLOBMSG_TYPE_STRING || !blobmsg_check_attr(cur, false))
- continue;
-
uint8_t buf[256];
char *domain = blobmsg_get_string(cur);
size_t domainlen = strlen(domain);
+ int len;
+
+ if (blobmsg_type(cur) != BLOBMSG_TYPE_STRING || !blobmsg_check_attr(cur, false))
+ continue;
+
+ domain = blobmsg_get_string(cur);
+ domainlen = strlen(domain);
+
if (domainlen > 0 && domain[domainlen - 1] == '.')
domain[domainlen - 1] = 0;
- int len = dn_comp(domain, buf, sizeof(buf), NULL, NULL);
- if (len <= 0)
- goto err;
+ len = dn_comp(domain, buf, sizeof(buf), NULL, NULL);
+ if (len <= 0) {
+ syslog(LOG_ERR, "Invalid %s value configured for interface '%s'",
+ iface_attrs[IFACE_ATTR_DOMAIN].name, iface->name);
+
+ continue;
+ }
iface->search = realloc(iface->search, iface->search_len + len);
if (!iface->search)
if ((c = tb[IFACE_ATTR_DHCPV6_NA]))
iface->dhcpv6_na = blobmsg_get_bool(c);
+ if ((c = tb[IFACE_ATTR_DHCPV6_HOSTID_LEN])) {
+ uint32_t hostid_len = blobmsg_get_u32(c);
+
+ if (hostid_len >= HOSTID_LEN_MIN && hostid_len <= HOSTID_LEN_MAX)
+ iface->dhcpv6_hostid_len = hostid_len;
+ else
+ syslog(LOG_ERR, "Invalid %s value configured for interface '%s'",
+ iface_attrs[IFACE_ATTR_DHCPV6_HOSTID_LEN].name, iface->name);
+
+ }
+
if ((c = tb[IFACE_ATTR_RA_DEFAULT]))
iface->default_router = blobmsg_get_u32(c);
- if ((c = tb[IFACE_ATTR_RA_MANAGEMENT]))
- iface->ra_managed = blobmsg_get_u32(c);
+ if (!tb[IFACE_ATTR_RA_FLAGS] && !tb[IFACE_ATTR_RA_SLAAC] &&
+ (c = tb[IFACE_ATTR_RA_MANAGEMENT])) {
+ switch (blobmsg_get_u32(c)) {
+ case 0:
+ iface->ra_flags = ND_RA_FLAG_OTHER;
+ iface->ra_slaac = true;
+ break;
+ case 1:
+ iface->ra_flags = ND_RA_FLAG_OTHER|ND_RA_FLAG_MANAGED;
+ iface->ra_slaac = true;
+ break;
+ case 2:
+ iface->ra_flags = ND_RA_FLAG_OTHER|ND_RA_FLAG_MANAGED;
+ iface->ra_slaac = false;
+ break;
+ default:
+ break;
+ }
+ }
+
+ if ((c = tb[IFACE_ATTR_RA_FLAGS])) {
+ iface->ra_flags = 0;
+
+ if (parse_ra_flags(&iface->ra_flags, c) < 0)
+ syslog(LOG_ERR, "Invalid %s value configured for interface '%s'",
+ iface_attrs[IFACE_ATTR_RA_FLAGS].name, iface->name);
+ }
if ((c = tb[IFACE_ATTR_RA_REACHABLETIME])) {
uint32_t ra_reachabletime = blobmsg_get_u32(c);
- if (ra_reachabletime > 3600000)
- goto err;
- iface->ra_reachabletime = ra_reachabletime;
+ if (ra_reachabletime <= 3600000)
+ iface->ra_reachabletime = ra_reachabletime;
+ else
+ syslog(LOG_ERR, "Invalid %s value configured for interface '%s'",
+ iface_attrs[IFACE_ATTR_RA_REACHABLETIME].name, iface->name);
}
if ((c = tb[IFACE_ATTR_RA_RETRANSTIME])) {
uint32_t ra_retranstime = blobmsg_get_u32(c);
- if (ra_retranstime > 60000)
- goto err;
- iface->ra_retranstime = ra_retranstime;
+ if (ra_retranstime <= 60000)
+ iface->ra_retranstime = ra_retranstime;
+ else
+ syslog(LOG_ERR, "Invalid %s value configured for interface '%s'",
+ iface_attrs[IFACE_ATTR_RA_RETRANSTIME].name, iface->name);
}
if ((c = tb[IFACE_ATTR_RA_HOPLIMIT])) {
uint32_t ra_hoplimit = blobmsg_get_u32(c);
- if (ra_hoplimit > 255)
- goto err;
- iface->ra_hoplimit = ra_hoplimit;
+ if (ra_hoplimit <= 255)
+ iface->ra_hoplimit = ra_hoplimit;
+ else
+ syslog(LOG_ERR, "Invalid %s value configured for interface '%s'",
+ iface_attrs[IFACE_ATTR_RA_HOPLIMIT].name, iface->name);
}
if ((c = tb[IFACE_ATTR_RA_MTU])) {
uint32_t ra_mtu = blobmsg_get_u32(c);
- if (ra_mtu < 1280 || ra_mtu > 65535)
- goto err;
- iface->ra_mtu = ra_mtu;
+ if (ra_mtu >= 1280 || ra_mtu <= 65535)
+ iface->ra_mtu = ra_mtu;
+ else
+ syslog(LOG_ERR, "Invalid %s value configured for interface '%s'",
+ iface_attrs[IFACE_ATTR_RA_MTU].name, iface->name);
}
+ if ((c = tb[IFACE_ATTR_RA_SLAAC]))
+ iface->ra_slaac = blobmsg_get_bool(c);
+
if ((c = tb[IFACE_ATTR_RA_OFFLINK]))
iface->ra_not_onlink = blobmsg_get_bool(c);
else if (!strcmp(prio, "medium") || !strcmp(prio, "default"))
iface->route_preference = 0;
else
- goto err;
+ syslog(LOG_ERR, "Invalid %s mode configured for interface '%s'",
+ iface_attrs[IFACE_ATTR_RA_PREFERENCE].name, iface->name);
}
if ((c = tb[IFACE_ATTR_PD_MANAGER]))
if ((c = tb[IFACE_ATTR_PD_CER]) &&
inet_pton(AF_INET6, blobmsg_get_string(c), &iface->dhcpv6_pd_cer) < 1)
- goto err;
+ syslog(LOG_ERR, "Invalid %s value configured for interface '%s'",
+ iface_attrs[IFACE_ATTR_PD_CER].name, iface->name);
if ((c = tb[IFACE_ATTR_NDPROXY_ROUTING]))
iface->learn_routes = blobmsg_get_bool(c);
free(astr);
}
+ if (overwrite && (c = tb[IFACE_ATTR_NTP])) {
+ struct blob_attr *cur;
+ unsigned rem;
+
+ blobmsg_for_each_attr(cur, c, rem) {
+ if (blobmsg_type(cur) != BLOBMSG_TYPE_STRING || !blobmsg_check_attr(cur, false))
+ continue;
+
+ char *str = blobmsg_get_string(cur);
+ struct in_addr addr4;
+ struct in6_addr addr6;
+
+ if (inet_pton(AF_INET, str, &addr4) == 1) {
+ if (addr4.s_addr == INADDR_ANY)
+ goto err;
+
+ iface->dhcpv4_ntp = realloc(iface->dhcpv4_ntp,
+ (++iface->dhcpv4_ntp_cnt) * sizeof(*iface->dhcpv4_ntp));
+ if (!iface->dhcpv4_ntp)
+ goto err;
+
+ iface->dhcpv4_ntp[iface->dhcpv4_ntp_cnt - 1] = addr4;
+ } else if (inet_pton(AF_INET6, str, &addr6) == 1) {
+ if (IN6_IS_ADDR_UNSPECIFIED(&addr6))
+ goto err;
+
+ iface->dhcpv6_sntp = realloc(iface->dhcpv6_sntp,
+ (++iface->dhcpv6_sntp_cnt) * sizeof(*iface->dhcpv6_sntp));
+ if (!iface->dhcpv6_sntp)
+ goto err;
+
+ iface->dhcpv6_sntp[iface->dhcpv6_sntp_cnt - 1] = addr6;
+
+ if (!parse_ntp_options(&iface->dhcpv6_ntp_len, addr6, &iface->dhcpv6_ntp))
+ iface->dhcpv6_ntp_cnt++;
+ } else {
+ if (!parse_ntp_fqdn(&iface->dhcpv6_ntp_len, str, &iface->dhcpv6_ntp))
+ iface->dhcpv6_ntp_cnt++;
+ }
+ }
+ }
+
return 0;
err:
return NULL;
}
-struct lease *config_find_lease_by_hostid(const uint32_t hostid)
+struct lease *config_find_lease_by_hostid(const uint64_t hostid)
{
struct lease *l;
uci_foreach_element(&dhcp->sections, e) {
struct uci_section* s = uci_to_section(e);
if (!strcmp(s->type, "host"))
- set_lease(s);
+ set_lease_from_uci(s);
}
}
avl_for_each_element_safe(&interfaces, i, avl, tmp) {
- if (i->inuse) {
+ if (i->inuse && i->ifflags & IFF_RUNNING) {
/* Resolve hybrid mode */
if (i->dhcpv6 == MODE_HYBRID)
i->dhcpv6 = (master && master->dhcpv6 == MODE_RELAY) ?