#include <string.h>
#include <stdlib.h>
#include <stdio.h>
+#include <libgen.h>
+#include <sys/stat.h>
#include <limits.h>
#include <arpa/inet.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 = {
.params = route_attr,
};
+enum {
+ NEIGHBOR_INTERFACE,
+ NEIGHBOR_ADDRESS,
+ NEIGHBOR_MAC,
+ NEIGHBOR_PROXY,
+ NEIGHBOR_ROUTER,
+ __NEIGHBOR_MAX
+};
+
+static const struct blobmsg_policy neighbor_attr[__NEIGHBOR_MAX]={
+ [NEIGHBOR_INTERFACE]= { .name = "interface", .type = BLOBMSG_TYPE_STRING},
+ [NEIGHBOR_ADDRESS]= { .name = "ipaddr", .type = BLOBMSG_TYPE_STRING},
+ [NEIGHBOR_MAC]= { .name = "mac", .type = BLOBMSG_TYPE_STRING},
+ [NEIGHBOR_PROXY]= { .name = "proxy", .type = BLOBMSG_TYPE_BOOL},
+ [NEIGHBOR_ROUTER]= {.name = "router", .type = BLOBMSG_TYPE_BOOL},
+};
+
+const struct uci_blob_param_list neighbor_attr_list = {
+ .n_params = __NEIGHBOR_MAX,
+ .params = neighbor_attr,
+};
+
struct list_head prefixes = LIST_HEAD_INIT(prefixes);
static struct device_prefix *ula_prefix = NULL;
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;
- // Handle offlink addresses correctly
+ 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 &&
(addr->flags & DEVADDR_OFFLINK))
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;
}
}
+void
+interface_ip_add_neighbor(struct interface *iface, struct blob_attr *attr, bool v6)
+{
+ struct interface_ip_settings *ip;
+ struct blob_attr *tb[__NEIGHBOR_MAX], *cur;
+ struct device_neighbor *neighbor;
+ int af = v6 ? AF_INET6: AF_INET;
+ struct ether_addr *ea;
+
+ blobmsg_parse(neighbor_attr, __NEIGHBOR_MAX, tb, blobmsg_data(attr), blobmsg_data_len(attr));
+
+ if (!iface) {
+ if ((cur = tb[NEIGHBOR_INTERFACE]) == NULL)
+ return;
+
+ iface = vlist_find(&interfaces, blobmsg_data(cur), iface, node);
+
+ if (!iface)
+ return;
+
+ ip = &iface->config_ip;
+ } else
+ ip = &iface->proto_ip;
+
+ neighbor = calloc(1,sizeof(*neighbor));
+ 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;
+ } else
+ goto error;
+
+ if ((cur = tb[NEIGHBOR_MAC]) != NULL) {
+ neighbor->flags |= DEVNEIGH_MAC;
+ ea = ether_aton(blobmsg_data(cur));
+ if (!ea)
+ goto error;
+
+ memcpy(neighbor->macaddr, ea, 6);
+ }
+
+ if ((cur = tb[NEIGHBOR_PROXY]) != NULL)
+ neighbor->proxy = blobmsg_get_bool(cur);
+
+ if ((cur = tb[NEIGHBOR_ROUTER]) != NULL)
+ neighbor->router = blobmsg_get_bool(cur);
+
+ vlist_add(&ip->neighbor, &neighbor->node, neighbor);
+ return;
+
+error:
+ free(neighbor);
+}
+
void
interface_ip_add_route(struct interface *iface, struct blob_attr *attr, bool v6)
{
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;
}
}
route->flags |= DEVROUTE_MTU;
}
- // Use source-based routing
+ /* Use source-based routing */
if ((cur = tb[ROUTE_SOURCE]) != NULL) {
char *saveptr, *source = alloca(blobmsg_data_len(cur));
memcpy(source, blobmsg_data(cur), blobmsg_data_len(cur));
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_VALID]) != NULL) {
int64_t valid = blobmsg_get_u32(cur);
int64_t valid_until = valid + (int64_t)system_get_rtime();
- if (valid_until <= LONG_MAX && valid != 0xffffffffLL) // Catch overflow
+ if (valid_until <= LONG_MAX && valid != 0xffffffffLL) /* Catch overflow */
route->valid_until = valid_until;
}
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
+neighbor_cmp(const void *k1, const void *k2, void *ptr)
+{
+ const struct device_neighbor *n1 = k1, *n2 = k2;
+
+ return memcmp(&n1->addr, &n2->addr, sizeof(n2->addr));
}
static int
if (node_old) {
if (a_old->enabled && !keep) {
- //This is needed for source routing to work correctly. If a device
- //has two connections to a network using the same subnet, adding
- //only the network-rule will cause packets to be routed through the
- //first matching network (source IP matches both masks).
+ /*
+ * This is needed for source routing to work correctly. If a device
+ * has two connections to a network using the same subnet, adding
+ * only the network-rule will cause packets to be routed through the
+ * first matching network (source IP matches both masks)
+ */
if (a_old->policy_table)
interface_add_addr_rules(a_old, false);
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_proto_neighbor(struct vlist_tree *tree,
+ struct vlist_node * node_new,
+ struct vlist_node *node_old)
{
+ struct device *dev;
+ struct device_neighbor *neighbor_old, *neighbor_new;
struct interface_ip_settings *ip;
- struct interface *iface;
+ bool keep = false;
+
+ ip = container_of(tree, struct interface_ip_settings, neighbor);
+ dev = ip->iface->l3_dev.dev;
+
+ neighbor_old = container_of(node_old, struct device_neighbor, node);
+ neighbor_new = container_of(node_new, struct device_neighbor, node);
+
+ if (node_old && node_new) {
+ keep = (!memcmp(neighbor_old->macaddr, neighbor_new->macaddr, sizeof(neighbor_old->macaddr)) &&
+ (neighbor_old->proxy == neighbor_new->proxy) &&
+ (neighbor_old->router == neighbor_new->router));
+ }
+
+ if (node_old) {
+ if (!keep && neighbor_old->enabled)
+ system_del_neighbor(dev, neighbor_old);
+
+ free(neighbor_old);
+ }
+
+ if (node_new) {
+ if (!keep && ip->enabled)
+ if (system_add_neighbor(dev, neighbor_new))
+ neighbor_new->failed = true;
+
+ neighbor_new->enabled = ip->enabled;
+ }
+}
+
+static void
+__interface_update_route(struct interface_ip_settings *ip,
+ struct vlist_node *node_new,
+ struct vlist_node *node_old)
+{
+ 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
return false;
/* get mac address */
- uint8_t *macaddr = iface->l3_dev.dev->settings.macaddr;
uint8_t *ifaceid = addr->s6_addr + 8;
- memcpy(ifaceid,macaddr,3);
- memcpy(ifaceid + 5,macaddr + 3, 3);
+ memcpy(ifaceid, st.macaddr, 3);
+ memcpy(ifaceid + 5, st.macaddr + 3, 3);
ifaceid[3] = 0xff;
ifaceid[4] = 0xfe;
ifaceid[0] ^= 0x02;
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;
int mtu = system_update_ipv6_mtu(uplink->l3_dev.dev, 0);
int mtu_old = system_update_ipv6_mtu(l3_downlink, 0);
- if (mtu > 0 && mtu_old > mtu)
- system_update_ipv6_mtu(l3_downlink, mtu);
+ if (mtu > 0 && mtu_old != mtu) {
+ if (system_update_ipv6_mtu(l3_downlink, mtu) < 0 && mtu < mtu_old)
+ netifd_log_message(L_WARNING, "Failed to set IPv6 mtu to %d "
+ "on interface '%s'\n", mtu, iface->name);
+ }
}
assignment->enabled = true;
struct device_prefix_assignment *c;
struct interface *iface;
- // Delete all assignments
+ /* Delete all assignments */
while (!list_empty(&prefix->assignments)) {
c = list_first_entry(&prefix->assignments,
struct device_prefix_assignment, head);
if (!setup)
return;
- // End-of-assignment sentinel
+ /* End-of-assignment sentinel */
c = malloc(sizeof(*c) + 1);
if (!c)
return;
c->addr = in6addr_any;
list_add(&c->head, &prefix->assignments);
- // Excluded prefix
+ /* Excluded prefix */
if (prefix->excl_length > 0) {
const char name[] = "!excluded";
c = malloc(sizeof(*c) + sizeof(name));
iface->assignment_length > 64)
continue;
- // Test whether there is a matching class
+ /* Test whether there is a matching class */
if (!list_empty(&iface->assignment_classes)) {
bool found = false;
c->enabled = false;
memcpy(c->name, iface->name, namelen);
- // First process all custom assignments, put all others in later-list
+ /* First process all custom assignments, put all others in later-list */
if (c->assigned == -1 || !interface_prefix_assign(&prefix->assignments, c)) {
if (c->assigned != -1) {
c->assigned = -1;
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) {
+ 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)
+ list_del(&prefix->head);
+ } else
+ list_add(&prefix->head, &prefixes);
+ }
+}
static void
interface_update_prefix(struct vlist_tree *tree,
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
+ /* Move assignments and refresh addresses to update valid times */
list_splice(&prefix_old->assignments, &prefix_new->assignments);
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)
ip->iface->updated |= IUF_PREFIX;
} else if (node_new) {
- // Set null-route to avoid routing loops
+ /* Set null-route to avoid routing loops */
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
+ /* Remove null-route */
interface_update_prefix_assignments(prefix_old, false);
system_del_route(NULL, &route);
}
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;
}
}
-void
+static void
interface_add_dns_server(struct interface_ip_settings *ip, const char *str)
{
struct dns_server *s;
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)
continue;
- if (!blobmsg_check_attr(cur, NULL))
+ if (!blobmsg_check_attr(cur, false))
continue;
interface_add_dns_server(ip, blobmsg_data(cur));
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)
continue;
- if (!blobmsg_check_attr(cur, NULL))
+ if (!blobmsg_check_attr(cur, false))
continue;
interface_add_dns_search_domain(ip, blobmsg_data(cur));
}
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;
struct device_route *route;
+ struct device_neighbor *neighbor;
struct device *dev;
struct interface *iface;
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;
+ 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);
- if (route->enabled == _enabled)
+ vlist_for_each_element(&ip->neighbor, neighbor, node) {
+ if (neighbor->enabled == enabled)
continue;
- if (_enabled) {
- interface_set_route_info(ip->iface, route);
-
- if (system_add_route(dev, route))
- route->failed = true;
+ if (enabled) {
+ if(system_add_neighbor(dev, neighbor))
+ neighbor->failed = true;
} else
- system_del_route(dev, route);
- route->enabled = _enabled;
+ system_del_neighbor(dev, neighbor);
+
+ neighbor->enabled = enabled;
}
struct device_prefix *c;
if (!strcmp(a->name, ip->iface->name))
interface_set_prefix_address(a, c, ip->iface, enabled);
- if (ip->iface && ip->iface->policy_rules_set != 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_update(&ip->route);
vlist_update(&ip->addr);
vlist_update(&ip->prefix);
+ vlist_update(&ip->neighbor);
}
void
vlist_flush(&ip->route);
vlist_flush(&ip->addr);
vlist_flush(&ip->prefix);
- interface_write_resolv_conf();
+ vlist_flush(&ip->neighbor);
+ interface_write_resolv_conf(ip->iface->jail);
}
void
vlist_simple_flush_all(&ip->dns_search);
vlist_flush_all(&ip->route);
vlist_flush_all(&ip->addr);
+ vlist_flush_all(&ip->neighbor);
vlist_flush_all(&ip->prefix);
}
vlist_simple_init(&ip->dns_search, struct dns_search_domain, node);
vlist_simple_init(&ip->dns_servers, struct dns_server, node);
vlist_init(&ip->route, route_cmp, interface_update_proto_route);
+ vlist_init(&ip->neighbor, neighbor_cmp, interface_update_proto_neighbor);
vlist_init(&ip->addr, addr_cmp, interface_update_proto_addr);
vlist_init(&ip->prefix, prefix_cmp, interface_update_prefix);
}
projects / project / netifd.git / blobdiff