#include <string.h>
#include <stdlib.h>
#include <stdio.h>
+#include <libgen.h>
+#include <sys/stat.h>
#include <limits.h>
#include <arpa/inet.h>
#include <netinet/in.h>
-#ifdef linux
-#include <netinet/ether.h>
-#endif
-
#include "netifd.h"
#include "device.h"
#include "interface.h"
ROUTE_ONLINK,
ROUTE_TYPE,
ROUTE_PROTO,
+ ROUTE_DISABLED,
__ROUTE_MAX
};
[ROUTE_ONLINK] = { .name = "onlink", .type = BLOBMSG_TYPE_BOOL },
[ROUTE_TYPE] = { .name = "type", .type = BLOBMSG_TYPE_STRING },
[ROUTE_PROTO] = { .name = "proto", .type = BLOBMSG_TYPE_STRING },
+ [ROUTE_DISABLED] = { .name = "disabled", .type = BLOBMSG_TYPE_BOOL },
};
const struct uci_blob_param_list route_attr_list = {
static void
clear_if_addr(union if_addr *a, int mask)
{
- int m_bytes = (mask + 7) / 8;
+ size_t m_bytes = (mask + 7) / 8;
uint8_t m_clear = (1 << (m_bytes * 8 - mask)) - 1;
uint8_t *p = (uint8_t *) a;
if (v6 != ((addr->flags & DEVADDR_FAMILY) == DEVADDR_INET6))
continue;
+ if (((addr->flags & DEVADDR_FAMILY) == DEVADDR_INET4) &&
+ addr->point_to_point && a->in.s_addr == addr->point_to_point)
+ return true;
+
/* Handle offlink addresses correctly */
unsigned int mask = addr->mask;
if ((addr->flags & DEVADDR_FAMILY) == DEVADDR_INET6 &&
if (route->flags & DEVROUTE_TABLE)
continue;
- if (!*res || route->mask > (*res)->mask)
+ if (!*res || route->mask > (*res)->mask ||
+ ((route->mask == (*res)->mask) && (route->flags & DEVROUTE_METRIC)
+ && (route->metric < (*res)->metric)))
*res = route;
}
}
}
struct interface *
-interface_ip_add_target_route(union if_addr *addr, bool v6, struct interface *iface)
+interface_ip_add_target_route(union if_addr *addr, bool v6, struct interface *iface,
+ bool exclude)
{
struct device_route *route, *r_next = NULL;
bool defaultroute_target = false;
union if_addr addr_zero;
int addrsize = v6 ? sizeof(addr->in6) : sizeof(addr->in);
+ struct interface *exclude_iface = NULL;
+
+ if (exclude) {
+ exclude_iface = iface;
+ iface = NULL;
+ }
memset(&addr_zero, 0, sizeof(addr_zero));
if (memcmp(&addr_zero, addr, addrsize) == 0)
interface_ip_find_route_target(iface, addr, v6, &r_next);
} else {
vlist_for_each_element(&interfaces, iface, node) {
+ if (iface == exclude_iface)
+ continue;
+
/* look for locally addressable target first */
if (interface_ip_find_addr_target(iface, addr, v6))
return iface;
ip = &iface->proto_ip;
neighbor = calloc(1,sizeof(*neighbor));
- neighbor->flags = v6 ? DEVADDR_INET6 : DEVADDR_INET4;
-
if (!neighbor)
return;
+ neighbor->flags = v6 ? DEVADDR_INET6 : DEVADDR_INET4;
+
if ((cur = tb[NEIGHBOR_ADDRESS]) != NULL){
if (!inet_pton(af, blobmsg_data(cur), &neighbor->addr))
goto error;
struct blob_attr *tb[__ROUTE_MAX], *cur;
struct device_route *route;
int af = v6 ? AF_INET6 : AF_INET;
+ bool no_device = false;
blobmsg_parse(route_attr, __ROUTE_MAX, tb, blobmsg_data(attr), blobmsg_data_len(attr));
+ if ((cur = tb[ROUTE_DISABLED]) != NULL && blobmsg_get_bool(cur))
+ return;
+
if (!iface) {
- if ((cur = tb[ROUTE_INTERFACE]) == NULL)
- return;
+ if ((cur = tb[ROUTE_INTERFACE]) == NULL) {
+ iface = vlist_find(&interfaces, "loopback", iface, node);
+ no_device = true;
+ } else {
+ iface = vlist_find(&interfaces, blobmsg_data(cur), iface, node);
+ }
- iface = vlist_find(&interfaces, blobmsg_data(cur), iface, node);
if (!iface)
return;
if ((cur = tb[ROUTE_TARGET]) != NULL) {
if (!parse_ip_and_netmask(af, blobmsg_data(cur), &route->addr, &route->mask)) {
- DPRINTF("Failed to parse route target: %s\n", (char *) blobmsg_data(cur));
+ D(INTERFACE, "Failed to parse route target: %s", (char *) blobmsg_data(cur));
goto error;
}
+
+ /* Mask out IPv4 host bits to avoid "Invalid prefix for given prefix length" */
+ if (af == AF_INET && route->mask < 32)
+ clear_if_addr(&route->addr, route->mask);
}
if ((cur = tb[ROUTE_GATEWAY]) != NULL) {
if (!inet_pton(af, blobmsg_data(cur), &route->nexthop)) {
- DPRINTF("Failed to parse route gateway: %s\n", (char *) blobmsg_data(cur));
+ D(INTERFACE, "Failed to parse route gateway: %s", (char *) blobmsg_data(cur));
goto error;
}
}
const char *mask = strtok_r(NULL, "/", &saveptr);
if (!addr || inet_pton(af, addr, &route->source) < 1) {
- DPRINTF("Failed to parse route source: %s\n", addr ? addr : "NULL");
+ D(INTERFACE, "Failed to parse route source: %s", addr ? addr : "NULL");
goto error;
}
if ((cur = tb[ROUTE_TABLE]) != NULL) {
if (!system_resolve_rt_table(blobmsg_data(cur), &route->table)) {
- DPRINTF("Failed to resolve routing table: %s\n", (char *) blobmsg_data(cur));
+ D(INTERFACE, "Failed to resolve routing table: %s", (char *) blobmsg_data(cur));
goto error;
}
if ((cur = tb[ROUTE_TYPE]) != NULL) {
if (!system_resolve_rt_type(blobmsg_data(cur), &route->type)) {
- DPRINTF("Failed to resolve routing type: %s\n", (char *) blobmsg_data(cur));
+ D(INTERFACE, "Failed to resolve routing type: %s", (char *) blobmsg_data(cur));
goto error;
}
route->flags |= DEVROUTE_TYPE;
if ((cur = tb[ROUTE_PROTO]) != NULL) {
if (!system_resolve_rt_proto(blobmsg_data(cur), &route->proto)) {
- DPRINTF("Failed to resolve proto type: %s\n", (char *) blobmsg_data(cur));
+ D(INTERFACE, "Failed to resolve proto type: %s", (char *) blobmsg_data(cur));
goto error;
}
route->flags |= DEVROUTE_PROTO;
}
- interface_set_route_info(iface, route);
+ if (no_device)
+ route->flags |= DEVROUTE_NODEV;
+ else
+ interface_set_route_info(iface, route);
+
vlist_add(&ip->route, &route->node, route);
return;
static int
addr_cmp(const void *k1, const void *k2, void *ptr)
{
- return memcmp(k1, k2, sizeof(struct device_addr) -
- offsetof(struct device_addr, flags));
+ const struct device_addr *a1 = k1;
+ const struct device_addr *a2 = k2;
+ const int cmp_offset = offsetof(struct device_addr, flags);
+ const int cmp_size = sizeof(struct device_addr) - cmp_offset;
+
+ if (a1->index != a2->index)
+ return a1->index - a2->index;
+ return memcmp(k1+cmp_offset, k2+cmp_offset, cmp_size);
}
static int
if (!(a_old->flags & DEVADDR_EXTERNAL)) {
interface_handle_subnet_route(iface, a_old, false);
system_del_address(dev, a_old);
+
+ if ((a_old->flags & DEVADDR_OFFLINK) && (a_old->mask < (v6 ? 128 : 32))) {
+ struct device_route route;
+
+ memset(&route, 0, sizeof(route));
+ route.flags = v6 ? DEVADDR_INET6 : DEVADDR_INET4;
+ route.metric = INT32_MAX;
+ route.mask = a_old->mask;
+ route.addr = a_old->addr;
+
+ clear_if_addr(&route.addr, route.mask);
+
+ /* Delete null-route */
+ system_del_route(NULL, &route);
+ }
+
}
}
free(a_old->pclass);
a_new->enabled = true;
if ((a_new->flags & DEVADDR_FAMILY) == DEVADDR_INET6)
- v6 = true;
+ v6 = true;
a_new->policy_table = (v6) ? iface->ip6table : iface->ip4table;
}
if (!keep) {
+ if (!(a_new->flags & DEVADDR_EXTERNAL) &&
+ (a_new->flags & DEVADDR_OFFLINK) &&
+ (a_new->mask < (v6 ? 128 : 32))) {
+ struct device_route route;
+
+ memset(&route, 0, sizeof(route));
+ route.flags = v6 ? DEVADDR_INET6 : DEVADDR_INET4;
+ route.metric = INT32_MAX;
+ route.mask = a_new->mask;
+ route.addr = a_new->addr;
+
+ clear_if_addr(&route.addr, route.mask);
+
+ /*
+ * In case off link is specifed as address property
+ * add null-route to avoid routing loops
+ */
+ system_add_route(NULL, &route);
+ }
+
if (a_new->policy_table)
interface_add_addr_rules(a_new, true);
}
}
static void
-interface_update_proto_route(struct vlist_tree *tree,
- struct vlist_node *node_new,
- struct vlist_node *node_old)
+__interface_update_route(struct interface_ip_settings *ip,
+ struct vlist_node *node_new,
+ struct vlist_node *node_old)
{
- struct interface_ip_settings *ip;
- struct interface *iface;
+ struct interface *iface = ip->iface;
struct device *dev;
struct device_route *route_old, *route_new;
bool keep = false;
- ip = container_of(tree, struct interface_ip_settings, route);
- iface = ip->iface;
dev = iface->l3_dev.dev;
if (!node_new || !node_old)
}
}
+static void
+interface_update_proto_route(struct vlist_tree *tree,
+ struct vlist_node *node_new,
+ struct vlist_node *node_old)
+{
+ struct interface_ip_settings *ip;
+
+ ip = container_of(tree, struct interface_ip_settings, route);
+ __interface_update_route(ip, node_new, node_old);
+}
+
static void
interface_update_host_route(struct vlist_tree *tree,
struct vlist_node *node_new,
struct vlist_node *node_old)
{
struct interface *iface;
- struct device *dev;
- struct device_route *route_old, *route_new;
iface = container_of(tree, struct interface, host_routes);
- dev = iface->l3_dev.dev;
-
- route_old = container_of(node_old, struct device_route, node);
- route_new = container_of(node_new, struct device_route, node);
-
- if (node_old) {
- system_del_route(dev, route_old);
- free(route_old);
- }
-
- if (node_new) {
- if (system_add_route(dev, route_new))
- route_new->failed = true;
- }
+ __interface_update_route(&iface->proto_ip, node_new, node_old);
}
static void
addr.addr.in6 = assignment->addr;
addr.mask = assignment->length;
- addr.flags = DEVADDR_INET6 | DEVADDR_OFFLINK;
+ addr.flags = DEVADDR_INET6;
addr.preferred_until = prefix->preferred_until;
addr.valid_until = prefix->valid_until;
if (!add && assignment->enabled) {
time_t now = system_get_rtime();
- addr.preferred_until = now;
- if (!addr.valid_until || addr.valid_until - now > 7200)
- addr.valid_until = now + 7200;
+ if (addr.valid_until && addr.valid_until - 1 <= now) {
+ addr.valid_until = 0;
+ addr.preferred_until = 0;
+ } else {
+ /* Address is still valid; pass its ownership to kernel (see L-14 RFC 7084). */
+ addr.preferred_until = now;
+
+ if (!addr.valid_until || addr.valid_until > now + 7200)
+ addr.valid_until = now + 7200;
+ }
if (iface->ip6table)
set_ip_source_policy(false, true, IPRULE_PRIORITY_ADDR_MASK, &addr.addr,
interface_set_route_info(iface, &route);
system_del_route(l3_downlink, &route);
- system_add_address(l3_downlink, &addr);
+ if (addr.valid_until)
+ system_add_address(l3_downlink, &addr);
+ else
+ system_del_address(l3_downlink, &addr);
assignment->addr = in6addr_any;
assignment->enabled = false;
route.addr = addr.addr;
}
+ addr.flags |= DEVADDR_OFFLINK;
if (system_add_address(l3_downlink, &addr))
return;
static bool refresh = false;
if (!hint && refresh) {
struct device_prefix *p;
- list_for_each_entry(p, &prefixes, head)
- interface_update_prefix_assignments(p, true);
+ time_t now = system_get_rtime();
+
+ list_for_each_entry(p, &prefixes, head) {
+ bool valid = !(p->valid_until && p->valid_until - 1 <= now);
+
+ interface_update_prefix_assignments(p, valid);
+ }
}
refresh = hint;
}
void interface_update_prefix_delegation(struct interface_ip_settings *ip)
{
struct device_prefix *prefix;
+ time_t now = system_get_rtime();
vlist_for_each_element(&ip->prefix, prefix, node) {
- interface_update_prefix_assignments(prefix, !ip->no_delegation);
+ bool valid = !(prefix->valid_until && prefix->valid_until - 1 <= now);
+
+ interface_update_prefix_assignments(prefix, !ip->no_delegation && valid);
if (ip->no_delegation) {
if (prefix->head.next)
route.mask = (node_new) ? prefix_new->length : prefix_old->length;
route.addr.in6 = (node_new) ? prefix_new->addr : prefix_old->addr;
-
struct device_prefix_assignment *c;
struct interface *iface;
+ bool new_valid = node_new && !(prefix_new->valid_until && prefix_new->valid_until - 1 <= system_get_rtime());
if (node_old && node_new) {
/* Move assignments and refresh addresses to update valid times */
list_for_each_entry(c, &prefix_new->assignments, head)
if ((iface = vlist_find(&interfaces, c->name, iface, node)))
- interface_set_prefix_address(c, prefix_new, iface, true);
+ interface_set_prefix_address(c, prefix_new, iface, new_valid);
if (prefix_new->preferred_until != prefix_old->preferred_until ||
prefix_new->valid_until != prefix_old->valid_until)
system_add_route(NULL, &route);
if (!prefix_new->iface || !prefix_new->iface->proto_ip.no_delegation)
- interface_update_prefix_assignments(prefix_new, true);
+ interface_update_prefix_assignments(prefix_new, new_valid);
} else if (node_old) {
/* Remove null-route */
interface_update_prefix_assignments(prefix_old, false);
uint8_t length, time_t valid_until, time_t preferred_until,
struct in6_addr *excl_addr, uint8_t excl_length, const char *pclass)
{
+ union if_addr a = { .in6 = *addr };
+
if (!pclass)
pclass = (iface) ? iface->name : "local";
if (!prefix)
return NULL;
+ clear_if_addr(&a, length);
+
prefix->length = length;
- prefix->addr = *addr;
+ prefix->addr = a.in6;
prefix->preferred_until = preferred_until;
prefix->valid_until = valid_until;
prefix->iface = iface;
return;
add:
- D(INTERFACE, "Add IPv%c DNS server: %s\n",
+ D(INTERFACE, "Add IPv%c DNS server: %s",
s->af == AF_INET6 ? '6' : '4', str);
vlist_simple_add(&ip->dns_servers, &s->node);
}
interface_add_dns_server_list(struct interface_ip_settings *ip, struct blob_attr *list)
{
struct blob_attr *cur;
- int rem;
+ size_t rem;
blobmsg_for_each_attr(cur, list, rem) {
if (blobmsg_type(cur) != BLOBMSG_TYPE_STRING)
if (!s)
return;
- D(INTERFACE, "Add DNS search domain: %s\n", str);
+ D(INTERFACE, "Add DNS search domain: %s", str);
memcpy(s->name, str, len);
vlist_simple_add(&ip->dns_search, &s->node);
}
interface_add_dns_search_list(struct interface_ip_settings *ip, struct blob_attr *list)
{
struct blob_attr *cur;
- int rem;
+ size_t rem;
blobmsg_for_each_attr(cur, list, rem) {
if (blobmsg_type(cur) != BLOBMSG_TYPE_STRING)
}
static void
-__interface_write_dns_entries(FILE *f)
+__interface_write_dns_entries(FILE *f, const char *jail)
{
struct interface *iface;
struct {
if (iface->state != IFS_UP)
continue;
+ if (jail && (!iface->jail || strcmp(jail, iface->jail)))
+ continue;
+
if (vlist_simple_empty(&iface->proto_ip.dns_search) &&
vlist_simple_empty(&iface->proto_ip.dns_servers) &&
vlist_simple_empty(&iface->config_ip.dns_search) &&
}
void
-interface_write_resolv_conf(void)
+interface_write_resolv_conf(const char *jail)
{
- char *path = alloca(strlen(resolv_conf) + 5);
+ size_t plen = (jail ? strlen(jail) + 1 : 0 ) +
+ (strlen(resolv_conf) >= strlen(DEFAULT_RESOLV_CONF) ?
+ strlen(resolv_conf) : strlen(DEFAULT_RESOLV_CONF) ) + 1;
+ char *path = alloca(plen);
+ char *dpath = alloca(plen);
+ char *tmppath = alloca(plen + 4);
FILE *f;
uint32_t crcold, crcnew;
- sprintf(path, "%s.tmp", resolv_conf);
- unlink(path);
- f = fopen(path, "w+");
+ if (jail) {
+ sprintf(path, "/tmp/resolv.conf-%s.d/resolv.conf.auto", jail);
+ strcpy(dpath, path);
+ dpath = dirname(dpath);
+ mkdir(dpath, 0755);
+ } else {
+ strcpy(path, resolv_conf);
+ }
+
+ sprintf(tmppath, "%s.tmp", path);
+ unlink(tmppath);
+ f = fopen(tmppath, "w+");
if (!f) {
- D(INTERFACE, "Failed to open %s for writing\n", path);
+ D(INTERFACE, "Failed to open %s for writing", path);
return;
}
- __interface_write_dns_entries(f);
+ __interface_write_dns_entries(f, jail);
fflush(f);
rewind(f);
fclose(f);
crcold = crcnew + 1;
- f = fopen(resolv_conf, "r");
+ f = fopen(path, "r");
if (f) {
crcold = crc32_file(f);
fclose(f);
}
if (crcold == crcnew) {
- unlink(path);
- } else if (rename(path, resolv_conf) < 0) {
- D(INTERFACE, "Failed to replace %s\n", resolv_conf);
- unlink(path);
+ unlink(tmppath);
+ } else if (rename(tmppath, path) < 0) {
+ D(INTERFACE, "Failed to replace %s", path);
+ unlink(tmppath);
}
}
+static void
+interface_ip_set_route_enabled(struct interface_ip_settings *ip,
+ struct device_route *route, bool enabled)
+{
+ struct device *dev = ip->iface->l3_dev.dev;
+
+ if (route->flags & DEVADDR_EXTERNAL)
+ return;
+
+ if (!enable_route(ip, route))
+ enabled = false;
+
+ if (route->enabled == enabled)
+ return;
+
+ if (enabled) {
+ interface_set_route_info(ip->iface, route);
+
+ if (system_add_route(dev, route))
+ route->failed = true;
+ } else
+ system_del_route(dev, route);
+
+ route->enabled = enabled;
+}
+
void interface_ip_set_enabled(struct interface_ip_settings *ip, bool enabled)
{
struct device_addr *addr;
if (iface->metric || addr->policy_table)
interface_handle_subnet_route(iface, addr, true);
+ if ((addr->flags & DEVADDR_OFFLINK) && (addr->mask < (v6 ? 128 : 32))) {
+ struct device_route route;
+
+ memset(&route, 0, sizeof(route));
+ route.flags = v6 ? DEVADDR_INET6 : DEVADDR_INET4;
+ route.metric = INT32_MAX;
+ route.mask = addr->mask;
+ route.addr = addr->addr;
+
+ clear_if_addr(&route.addr, route.mask);
+
+ /*
+ * In case off link is specifed as address property
+ * add null-route to avoid routing loops
+ */
+ system_add_route(NULL, &route);
+ }
+
if (addr->policy_table)
interface_add_addr_rules(addr, true);
} else {
interface_handle_subnet_route(iface, addr, false);
system_del_address(dev, addr);
+ if ((addr->flags & DEVADDR_OFFLINK) && (addr->mask < (v6 ? 128 : 32))) {
+ struct device_route route;
+
+ memset(&route, 0, sizeof(route));
+ route.flags = v6 ? DEVADDR_INET6 : DEVADDR_INET4;
+ route.metric = INT32_MAX;
+ route.mask = addr->mask;
+ route.addr = addr->addr;
+
+ clear_if_addr(&route.addr, route.mask);
+
+ /* Delete null-route */
+ system_del_route(NULL, &route);
+ }
+
if (addr->policy_table)
interface_add_addr_rules(addr, false);
}
addr->enabled = enabled;
}
- vlist_for_each_element(&ip->route, route, node) {
- bool _enabled = enabled;
-
- if (route->flags & DEVADDR_EXTERNAL)
- continue;
-
- if (!enable_route(ip, route))
- _enabled = false;
- if (route->enabled == _enabled)
- continue;
-
- if (_enabled) {
- interface_set_route_info(ip->iface, route);
-
- if (system_add_route(dev, route))
- route->failed = true;
- } else
- system_del_route(dev, route);
- route->enabled = _enabled;
- }
+ vlist_for_each_element(&ip->route, route, node)
+ interface_ip_set_route_enabled(ip, route, enabled);
+ if (ip == &iface->proto_ip)
+ vlist_for_each_element(&iface->host_routes, route, node)
+ interface_ip_set_route_enabled(ip, route, enabled);
vlist_for_each_element(&ip->neighbor, neighbor, node) {
if (neighbor->enabled == enabled)
if (ip->iface->policy_rules_set != enabled &&
ip->iface->l3_dev.dev) {
- set_ip_lo_policy(enabled, true, ip->iface);
+ if (ip->iface->l3_dev.dev->settings.ipv6) {
+ set_ip_lo_policy(enabled, true, ip->iface);
+ set_ip_source_policy(enabled, true, IPRULE_PRIORITY_REJECT + ip->iface->l3_dev.dev->ifindex,
+ NULL, 0, 0, ip->iface, "failed_policy", true);
+ }
set_ip_lo_policy(enabled, false, ip->iface);
- set_ip_source_policy(enabled, true, IPRULE_PRIORITY_REJECT + ip->iface->l3_dev.dev->ifindex,
- NULL, 0, 0, ip->iface, "failed_policy", true);
ip->iface->policy_rules_set = enabled;
}
}
vlist_flush(&ip->addr);
vlist_flush(&ip->prefix);
vlist_flush(&ip->neighbor);
- interface_write_resolv_conf();
+ interface_write_resolv_conf(ip->iface->jail);
}
void
projects / project / netifd.git / blobdiff