IFACE_ATTR_DHCPV4,
IFACE_ATTR_DHCPV6,
IFACE_ATTR_NDP,
+ IFACE_ATTR_ROUTER,
IFACE_ATTR_DNS,
IFACE_ATTR_DOMAIN,
+ IFACE_ATTR_FILTER_CLASS,
+ IFACE_ATTR_DHCPV6_RAW,
IFACE_ATTR_RA_DEFAULT,
IFACE_ATTR_RA_MANAGEMENT,
IFACE_ATTR_RA_OFFLINK,
IFACE_ATTR_RA_PREFERENCE,
+ IFACE_ATTR_RA_ADVROUTER,
+ IFACE_ATTR_PD_MANAGER,
+ IFACE_ATTR_PD_CER,
IFACE_ATTR_NDPROXY_ROUTING,
IFACE_ATTR_NDPROXY_SLAVE,
- IFACE_ATTR_NDPROXY_STATIC,
IFACE_ATTR_MAX
};
[IFACE_ATTR_DHCPV4] = { .name = "dhcpv4", .type = BLOBMSG_TYPE_STRING },
[IFACE_ATTR_DHCPV6] = { .name = "dhcpv6", .type = BLOBMSG_TYPE_STRING },
[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_DOMAIN] = { .name = "domain", .type = BLOBMSG_TYPE_ARRAY },
+ [IFACE_ATTR_FILTER_CLASS] = { .name = "filter_class", .type = BLOBMSG_TYPE_STRING },
+ [IFACE_ATTR_DHCPV6_RAW] = { .name = "dhcpv6_raw", .type = BLOBMSG_TYPE_STRING },
+ [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_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_NDPROXY_STATIC] = { .name = "ndproxy_static", .type = BLOBMSG_TYPE_ARRAY },
};
static const struct uci_blob_param_info iface_attr_info[IFACE_ATTR_MAX] = {
[IFACE_ATTR_UPSTREAM] = { .type = BLOBMSG_TYPE_STRING },
[IFACE_ATTR_DNS] = { .type = BLOBMSG_TYPE_STRING },
[IFACE_ATTR_DOMAIN] = { .type = BLOBMSG_TYPE_STRING },
- [IFACE_ATTR_NDPROXY_STATIC] = { .type = BLOBMSG_TYPE_STRING },
};
const struct uci_blob_param_list interface_attr_list = {
free(iface->dns);
free(iface->search);
free(iface->upstream);
- free(iface->static_ndp);
+ free(iface->dhcpv4_router);
free(iface->dhcpv4_dns);
+ free(iface->dhcpv6_raw);
+ free(iface->filter_class);
memset(&iface->ra, 0, sizeof(*iface) - offsetof(struct interface, ra));
}
lease->duid_len = len;
}
- if ((c = tb[LEASE_ATTR_HOSTID]))
- if (odhcpd_unhexlify((uint8_t*)&lease->hostid, sizeof(lease->hostid),
- blobmsg_get_string(c)) < 0)
+ if ((c = tb[LEASE_ATTR_HOSTID])) {
+ errno = 0;
+ lease->hostid = strtoul(blobmsg_get_string(c), NULL, 16);
+ if (errno)
goto err;
+ }
list_add(&lease->head, &leases);
return 0;
strncpy(iface->name, name, sizeof(iface->name) - 1);
list_add(&iface->head, &interfaces);
+ overwrite = true;
}
const char *ifname = NULL;
if (ifname)
strncpy(iface->ifname, ifname, sizeof(iface->ifname) - 1);
+ if ((iface->ifindex = if_nametoindex(iface->ifname)) <= 0)
+ return -1;
+
iface->inuse = true;
if ((c = tb[IFACE_ATTR_DYNAMICDHCP]))
goto err;
}
+ if ((c = tb[IFACE_ATTR_ROUTER])) {
+ struct blob_attr *cur;
+ unsigned rem;
+
+ blobmsg_for_each_attr(cur, c, rem) {
+ if (blobmsg_type(cur) != BLOBMSG_TYPE_STRING || !blobmsg_check_attr(cur, NULL))
+ 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));
+ if (!iface->dhcpv4_router)
+ goto err;
+
+ iface->dhcpv4_router[iface->dhcpv4_router_cnt - 1] = addr4;
+ } else {
+ goto err;
+ }
+ }
+ }
+
if ((c = tb[IFACE_ATTR_DNS])) {
struct blob_attr *cur;
unsigned rem;
continue;
uint8_t buf[256];
- int len = dn_comp(blobmsg_get_string(cur), buf, sizeof(buf), NULL, NULL);
+ char *domain = blobmsg_get_string(cur);
+ size_t 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;
}
}
+ if ((c = tb[IFACE_ATTR_FILTER_CLASS])) {
+ iface->filter_class = realloc(iface->filter_class, blobmsg_data_len(c) + 1);
+ memcpy(iface->filter_class, blobmsg_get_string(c), blobmsg_data_len(c) + 1);
+ }
+
+ if ((c = tb[IFACE_ATTR_DHCPV6_RAW])) {
+ iface->dhcpv6_raw_len = blobmsg_data_len(c) / 2;
+ iface->dhcpv6_raw = realloc(iface->dhcpv6_raw, iface->dhcpv6_raw_len);
+ odhcpd_unhexlify(iface->dhcpv6_raw, iface->dhcpv6_raw_len, blobmsg_get_string(c));
+ }
+
if ((c = tb[IFACE_ATTR_RA_DEFAULT]))
iface->default_router = blobmsg_get_u32(c);
if ((c = tb[IFACE_ATTR_RA_MANAGEMENT]))
iface->managed = blobmsg_get_u32(c);
+ else if (overwrite)
+ iface->managed = 1;
if ((c = tb[IFACE_ATTR_RA_OFFLINK]))
iface->ra_not_onlink = blobmsg_get_bool(c);
+ if ((c = tb[IFACE_ATTR_RA_ADVROUTER]))
+ iface->ra_advrouter = blobmsg_get_bool(c);
+
if ((c = tb[IFACE_ATTR_RA_PREFERENCE])) {
const char *prio = blobmsg_get_string(c);
goto err;
}
+ if ((c = tb[IFACE_ATTR_PD_MANAGER]))
+ strncpy(iface->dhcpv6_pd_manager, blobmsg_get_string(c),
+ sizeof(iface->dhcpv6_pd_manager) - 1);
+
+ if ((c = tb[IFACE_ATTR_PD_CER]) &&
+ inet_pton(AF_INET6, blobmsg_get_string(c), &iface->dhcpv6_pd_cer) < 1)
+ goto err;
+
if ((c = tb[IFACE_ATTR_NDPROXY_ROUTING]))
iface->learn_routes = blobmsg_get_bool(c);
- else
+ else if (overwrite)
iface->learn_routes = true;
if ((c = tb[IFACE_ATTR_NDPROXY_SLAVE]))
iface->external = blobmsg_get_bool(c);
- if ((c = tb[IFACE_ATTR_NDPROXY_STATIC])) {
- struct blob_attr *cur;
- unsigned rem;
-
- blobmsg_for_each_attr(cur, c, rem) {
- if (blobmsg_type(cur) != BLOBMSG_TYPE_STRING || !blobmsg_check_attr(cur, NULL))
- continue;
-
- int len = blobmsg_data_len(cur);
- iface->static_ndp = realloc(iface->static_ndp, iface->static_ndp_len + len);
- if (!iface->static_ndp)
- goto err;
-
- memcpy(&iface->static_ndp[iface->static_ndp_len], blobmsg_get_string(cur), len);
- iface->static_ndp_len += len;
- }
- }
-
- iface->ignore = (iface->ifindex = if_nametoindex(iface->ifname)) <= 0;
return 0;
err:
void odhcpd_reload(void)
{
struct uci_context *uci = uci_alloc_context();
- struct lease *l;
- list_for_each_entry(l, &leases, head) {
+ while (!list_empty(&leases)) {
+ struct lease *l = list_first_entry(&leases, struct lease, head);
list_del(&l->head);
free(l->duid);
free(l);
ubus_apply_network();
#endif
+ bool any_dhcpv6_slave = false, any_ra_slave = false, any_ndp_slave = false;
+
+ // Test for
+ list_for_each_entry(i, &interfaces, head) {
+ if (i->master)
+ continue;
+
+ if (i->dhcpv6 == RELAYD_HYBRID || i->dhcpv6 == RELAYD_RELAY)
+ any_dhcpv6_slave = true;
+
+ if (i->ra == RELAYD_HYBRID || i->ra == RELAYD_RELAY)
+ any_ra_slave = true;
+
+ if (i->ndp == RELAYD_HYBRID || i->ndp == RELAYD_RELAY)
+ any_ndp_slave = true;
+ }
+
// Evaluate hybrid mode for master
list_for_each_entry(i, &interfaces, head) {
if (!i->master)
enum odhcpd_mode hybrid_mode = RELAYD_DISABLED;
#ifdef WITH_UBUS
- if (ubus_has_prefix(i->name, i->ifname))
+ if (!ubus_has_prefix(i->name, i->ifname))
hybrid_mode = RELAYD_RELAY;
#endif
if (i->dhcpv6 == RELAYD_HYBRID)
i->dhcpv6 = hybrid_mode;
+ if (i->dhcpv6 == RELAYD_RELAY && !any_dhcpv6_slave)
+ i->dhcpv6 = RELAYD_DISABLED;
+
if (i->ra == RELAYD_HYBRID)
i->ra = hybrid_mode;
+ if (i->ra == RELAYD_RELAY && !any_ra_slave)
+ i->ra = RELAYD_DISABLED;
+
if (i->ndp == RELAYD_HYBRID)
i->ndp = hybrid_mode;
+ if (i->ndp == RELAYD_RELAY && !any_ndp_slave)
+ i->ndp = RELAYD_DISABLED;
+
if (i->dhcpv6 == RELAYD_RELAY || i->ra == RELAYD_RELAY || i->ndp == RELAYD_RELAY)
master = i;
}
if (i->ndp == RELAYD_HYBRID)
i->ndp = (master && master->ndp == RELAYD_RELAY) ?
- RELAYD_RELAY : RELAYD_SERVER;
+ RELAYD_RELAY : RELAYD_DISABLED;
setup_router_interface(i, true);
setup_dhcpv6_interface(i, true);
odhcpd_reload();
uloop_run();
+
+ while (!list_empty(&interfaces))
+ close_interface(list_first_entry(&interfaces, struct interface, head));
}
projects / project / odhcpd.git / blobdiff