X-Git-Url: https://git.archive.openwrt.org/?p=project%2Fnetifd.git;a=blobdiff_plain;f=interface-ip.c;h=fed7d725c7c37b7b9742aa3300c81c3729747966;hp=2b876618c9d50efbadb80984bcac27973e4fe8a6;hb=b8c54175393d6cfd07ea641230bd785ce9aee0cc;hpb=8dacaf753b57c703f215b0c844b412b64183ac81 diff --git a/interface-ip.c b/interface-ip.c index 2b87661..fed7d72 100644 --- a/interface-ip.c +++ b/interface-ip.c @@ -15,8 +15,8 @@ #include #include #include -#include +#include #include #include "netifd.h" @@ -36,6 +36,7 @@ enum { ROUTE_MTU, ROUTE_VALID, ROUTE_TABLE, + ROUTE_SOURCE, __ROUTE_MAX }; @@ -48,9 +49,10 @@ static const struct blobmsg_policy route_attr[__ROUTE_MAX] = { [ROUTE_MTU] = { .name = "mtu", .type = BLOBMSG_TYPE_INT32 }, [ROUTE_TABLE] = { .name = "table", .type = BLOBMSG_TYPE_STRING }, [ROUTE_VALID] = { .name = "valid", .type = BLOBMSG_TYPE_INT32 }, + [ROUTE_SOURCE] = { .name = "source", .type = BLOBMSG_TYPE_STRING }, }; -const struct config_param_list route_attr_list = { +const struct uci_blob_param_list route_attr_list = { .n_params = __ROUTE_MAX, .params = route_attr, }; @@ -90,6 +92,59 @@ match_if_addr(union if_addr *a1, union if_addr *a2, int mask) return !memcmp(p1, p2, sizeof(*p1)); } +static int set_ip_source_policy(bool add, bool v6, unsigned int priority, + const union if_addr *addr, uint8_t mask, unsigned int table, + struct interface *in_iface, const char *action) +{ + struct iprule rule = { + .flags = IPRULE_PRIORITY, + .priority = priority + }; + + if (addr) { + rule.flags |= IPRULE_SRC; + rule.src_addr = *addr; + rule.src_mask = mask; + } + + if (table) { + rule.flags |= IPRULE_LOOKUP; + rule.lookup = table; + + if (!rule.lookup) + return 0; + } else if (action) { + rule.flags |= IPRULE_ACTION; + system_resolve_iprule_action(action, &rule.action); + } + + if (in_iface && in_iface->l3_dev.dev) { + rule.flags |= IPRULE_IN; + strcpy(rule.in_dev, in_iface->l3_dev.dev->ifname); + } + + rule.flags |= (v6) ? IPRULE_INET6 : IPRULE_INET4; + + return (add) ? system_add_iprule(&rule) : system_del_iprule(&rule); +} + +static int set_ip_lo_policy(bool add, bool v6, struct interface *iface) +{ + struct iprule rule = { + .flags = IPRULE_IN | IPRULE_LOOKUP | IPRULE_PRIORITY, + .priority = IPRULE_PRIORITY_NW + iface->l3_dev.dev->ifindex, + .lookup = (v6) ? iface->ip6table : iface->ip4table, + .in_dev = "lo" + }; + + if (!rule.lookup) + return 0; + + rule.flags |= (v6) ? IPRULE_INET6 : IPRULE_INET4; + + return (add) ? system_add_iprule(&rule) : system_del_iprule(&rule); +} + static bool __find_ip_addr_target(struct interface_ip_settings *ip, union if_addr *a, bool v6) { @@ -102,7 +157,13 @@ __find_ip_addr_target(struct interface_ip_settings *ip, union if_addr *a, bool v if (v6 != ((addr->flags & DEVADDR_FAMILY) == DEVADDR_INET6)) continue; - if (!match_if_addr(&addr->addr, a, addr->mask)) + // Handle offlink addresses correctly + unsigned int mask = addr->mask; + if ((addr->flags & DEVADDR_FAMILY) == DEVADDR_INET6 && + (addr->flags & DEVADDR_OFFLINK)) + mask = 128; + + if (!match_if_addr(&addr->addr, a, mask)) continue; return true; @@ -151,9 +212,8 @@ interface_ip_find_route_target(struct interface *iface, union if_addr *a, } struct interface * -interface_ip_add_target_route(union if_addr *addr, bool v6) +interface_ip_add_target_route(union if_addr *addr, bool v6, struct interface *iface) { - struct interface *iface; struct device_route *route, *r_next = NULL; bool defaultroute_target = false; int addrsize = v6 ? sizeof(addr->in6) : sizeof(addr->in); @@ -169,7 +229,7 @@ interface_ip_add_target_route(union if_addr *addr, bool v6) else memcpy(&route->addr, addr, addrsize); - vlist_for_each_element(&interfaces, iface, node) { + if (iface) { /* look for locally addressable target first */ if (interface_ip_find_addr_target(iface, addr, v6)) goto done; @@ -177,6 +237,16 @@ interface_ip_add_target_route(union if_addr *addr, bool v6) /* do not stop at the first route, let the lookup compare * masks to find the best match */ interface_ip_find_route_target(iface, addr, v6, &r_next); + } else { + vlist_for_each_element(&interfaces, iface, node) { + /* look for locally addressable target first */ + if (interface_ip_find_addr_target(iface, addr, v6)) + goto done; + + /* do not stop at the first route, let the lookup compare + * masks to find the best match */ + interface_ip_find_route_target(iface, addr, v6, &r_next); + } } if (!r_next) { @@ -188,6 +258,7 @@ interface_ip_add_target_route(union if_addr *addr, bool v6) memcpy(&route->nexthop, &r_next->nexthop, sizeof(route->nexthop)); route->mtu = r_next->mtu; route->metric = r_next->metric; + route->table = r_next->table; done: route->iface = iface; @@ -205,6 +276,7 @@ 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 is_proto_route = !!iface; blobmsg_parse(route_attr, __ROUTE_MAX, tb, blobmsg_data(attr), blobmsg_data_len(attr)); @@ -257,6 +329,27 @@ interface_ip_add_route(struct interface *iface, struct blob_attr *attr, bool v6) route->flags |= DEVROUTE_MTU; } + // 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 *addr = strtok_r(source, "/", &saveptr); + 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); + goto error; + } + + route->sourcemask = (mask) ? atoi(mask) : ((af == AF_INET6) ? 128 : 32); + } + + if (is_proto_route) { + route->table = (v6) ? iface->ip6table : iface->ip4table; + route->flags |= DEVROUTE_SRCTABLE; + } + 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)); @@ -267,8 +360,12 @@ interface_ip_add_route(struct interface *iface, struct blob_attr *attr, bool v6) route->flags |= DEVROUTE_TABLE; } - if ((cur = tb[ROUTE_VALID]) != NULL) - route->valid_until = system_get_rtime() + blobmsg_get_u32(cur); + 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 + route->valid_until = valid_until; + } vlist_add(&ip->route, &route->node, route); return; @@ -289,22 +386,29 @@ route_cmp(const void *k1, const void *k2, void *ptr) { const struct device_route *r1 = k1, *r2 = k2; - if (r1->mask != r2->mask); + if (r1->mask != r2->mask) return r2->mask - r1->mask; - if (r1->metric != r2->metric); + if (r1->metric != r2->metric) return r1->metric - r2->metric; if (r1->flags != r2->flags) return r2->flags - r1->flags; + if (r1->sourcemask != r2->sourcemask) + return r1->sourcemask - r2->sourcemask; + + int maskcmp = memcmp(&r1->source, &r2->source, sizeof(r1->source)); + if (maskcmp) + return maskcmp; + return memcmp(&r1->addr, &r2->addr, sizeof(r1->addr)); } static int prefix_cmp(const void *k1, const void *k2, void *ptr) { - return memcmp(k1, k2, sizeof(struct device_prefix) - + return memcmp(k1, k2, offsetof(struct device_prefix, pclass) - offsetof(struct device_prefix, addr)); } @@ -345,12 +449,17 @@ interface_update_proto_addr(struct vlist_tree *tree, struct interface *iface; struct device *dev; struct device_addr *a_new = NULL, *a_old = NULL; + bool replace = false; bool keep = false; + bool v6 = false; ip = container_of(tree, struct interface_ip_settings, addr); iface = ip->iface; dev = iface->l3_dev.dev; + if (!node_new || !node_old) + iface->updated |= IUF_ADDRESS; + if (node_new) { a_new = container_of(node_new, struct device_addr, node); @@ -371,11 +480,13 @@ interface_update_proto_addr(struct vlist_tree *tree, if (a_new && a_old) { keep = true; - if (a_old->flags != a_new->flags || - a_old->valid_until != a_new->valid_until || - a_old->preferred_until != a_new->preferred_until) + if (a_old->flags != a_new->flags) keep = false; + if (a_old->valid_until != a_new->valid_until || + a_old->preferred_until != a_new->preferred_until) + replace = true; + if ((a_new->flags & DEVADDR_FAMILY) == DEVADDR_INET4 && a_new->broadcast != a_old->broadcast) keep = false; @@ -384,15 +495,48 @@ interface_update_proto_addr(struct vlist_tree *tree, if (node_old) { if (!(a_old->flags & DEVADDR_EXTERNAL) && a_old->enabled && !keep) { interface_handle_subnet_route(iface, a_old, false); + + if ((a_old->flags & DEVADDR_FAMILY) == DEVADDR_INET6) + v6 = true; + + unsigned int table = (v6) ? iface->ip6table : iface->ip4table; + + //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 (table) { + set_ip_source_policy(false, v6, IPRULE_PRIORITY_ADDR, &a_old->addr, + (v6) ? 128 : 32, table, NULL, NULL); + set_ip_source_policy(false, v6, IPRULE_PRIORITY_NW, &a_old->addr, + a_old->mask, table, NULL, NULL); + } + system_del_address(dev, a_old); } + free(a_old->pclass); free(a_old); } if (node_new) { a_new->enabled = true; - if (!(a_new->flags & DEVADDR_EXTERNAL) && !keep) { + if (!(a_new->flags & DEVADDR_EXTERNAL) && (!keep || replace)) { system_add_address(dev, a_new); + + if (!keep) { + if ((a_new->flags & DEVADDR_FAMILY) == DEVADDR_INET6) + v6 = true; + + unsigned int table = (v6) ? iface->ip6table : iface->ip4table; + + if (table) { + set_ip_source_policy(true, v6, IPRULE_PRIORITY_ADDR, &a_new->addr, + (v6) ? 128 : 32, table, NULL, NULL); + set_ip_source_policy(true, v6, IPRULE_PRIORITY_NW, &a_new->addr, + a_new->mask, table, NULL, NULL); + } + } + if ((a_new->flags & DEVADDR_OFFLINK) || iface->metric) interface_handle_subnet_route(iface, a_new, true); } @@ -423,15 +567,20 @@ interface_update_proto_route(struct vlist_tree *tree, iface = ip->iface; dev = iface->l3_dev.dev; + if (!node_new || !node_old) + iface->updated |= IUF_ROUTE; + route_old = container_of(node_old, struct device_route, node); route_new = container_of(node_new, struct device_route, node); if (node_old && node_new) - keep = !memcmp(&route_old->nexthop, &route_new->nexthop, sizeof(route_old->nexthop)); + keep = !memcmp(&route_old->nexthop, &route_new->nexthop, sizeof(route_old->nexthop)) && + (route_old->table == route_new->table); if (node_old) { if (!(route_old->flags & DEVADDR_EXTERNAL) && route_old->enabled && !keep) system_del_route(dev, route_old); + free(route_old); } @@ -500,9 +649,26 @@ interface_set_prefix_address(struct device_prefix_assignment *assignment, if (!addr.valid_until || addr.valid_until - now > 7200) addr.valid_until = now + 7200; system_add_address(l3_downlink, &addr); + if (prefix->iface) { + if (prefix->iface->ip6table) + set_ip_source_policy(false, true, IPRULE_PRIORITY_NW, &addr.addr, + addr.mask, prefix->iface->ip6table, iface, NULL); + + set_ip_source_policy(false, true, IPRULE_PRIORITY_REJECT, &addr.addr, + addr.mask, 0, iface, "unreachable"); + } + assignment->enabled = false; } else if (add && (iface->state == IFS_UP || iface->state == IFS_SETUP)) { system_add_address(l3_downlink, &addr); + if (prefix->iface && !assignment->enabled) { + set_ip_source_policy(true, true, IPRULE_PRIORITY_REJECT, &addr.addr, + addr.mask, 0, iface, "unreachable"); + + if (prefix->iface->ip6table) + set_ip_source_policy(true, true, IPRULE_PRIORITY_NW, &addr.addr, + addr.mask, prefix->iface->ip6table, iface, NULL); + } if (uplink && uplink->l3_dev.dev) { int mtu = system_update_ipv6_mtu( uplink->l3_dev.dev, 0); @@ -520,7 +686,7 @@ static bool interface_prefix_assign(struct list_head *list, struct device_prefix_assignment *c; list_for_each_entry(c, list, head) { if (assign->assigned != -1) { - if (assign->assigned > current && assign->assigned + asize < c->assigned) { + if (assign->assigned >= current && assign->assigned + asize < c->assigned) { list_add_tail(&assign->head, &c->head); return true; } @@ -573,16 +739,33 @@ static void interface_update_prefix_assignments(struct device_prefix *prefix, bo list_add(&c->head, &prefix->assignments); } + bool assigned_any = false; struct list_head assign_later = LIST_HEAD_INIT(assign_later); vlist_for_each_element(&interfaces, iface, node) { - if (iface->config_ip.assignment_length < 48 || - iface->config_ip.assignment_length > 64) + if (iface->assignment_length < 48 || + iface->assignment_length > 64) continue; + // Test whether there is a matching class + if (!list_empty(&iface->assignment_classes)) { + bool found = false; + + struct interface_assignment_class *c; + list_for_each_entry(c, &iface->assignment_classes, head) { + if (!strcmp(c->name, prefix->pclass)) { + found = true; + break; + } + } + + if (!found) + continue; + } + size_t namelen = strlen(iface->name) + 1; c = malloc(sizeof(*c) + namelen); - c->length = iface->config_ip.assignment_length; - c->assigned = iface->config_ip.assignment_hint; + c->length = iface->assignment_length; + c->assigned = iface->assignment_hint; c->enabled = false; memcpy(c->name, iface->name, namelen); @@ -593,24 +776,48 @@ static void interface_update_prefix_assignments(struct device_prefix *prefix, bo netifd_log_message(L_WARNING, "Failed to assign requested subprefix " "of size %hhu for %s, trying other\n", c->length, c->name); } - list_add_tail(&c->head, &assign_later); + + struct list_head *next = &assign_later; + struct device_prefix_assignment *n; + list_for_each_entry(n, &assign_later, head) { + if (n->length < c->length) { + next = &n->head; + break; + } + } + list_add_tail(&c->head, next); } + + if (c->assigned != -1) + assigned_any = true; } // Then try to assign all other + failed custom assignments while (!list_empty(&assign_later)) { c = list_first_entry(&assign_later, struct device_prefix_assignment, head); list_del(&c->head); - if (!interface_prefix_assign(&prefix->assignments, c)) { + + bool assigned = false; + do { + assigned = interface_prefix_assign(&prefix->assignments, c); + } while (!assigned && ++c->length <= 64); + + if (!assigned) { netifd_log_message(L_WARNING, "Failed to assign subprefix " "of size %hhu for %s\n", c->length, c->name); free(c); + } else { + assigned_any = true; } } list_for_each_entry(c, &prefix->assignments, head) if ((iface = vlist_find(&interfaces, c->name, iface, node))) interface_set_prefix_address(c, prefix, iface, true); + + if (!assigned_any) + netifd_log_message(L_WARNING, "You have delegated IPv6-prefixes but haven't assigned them " + "to any interface. Did you forget to set option ip6assign on your lan-interfaces?"); } @@ -635,6 +842,10 @@ interface_update_prefix(struct vlist_tree *tree, prefix_old = container_of(node_old, struct device_prefix, node); prefix_new = container_of(node_new, struct device_prefix, node); + struct interface_ip_settings *ip = container_of(tree, struct interface_ip_settings, prefix); + if (tree && (!node_new || !node_old)) + ip->iface->updated |= IUF_PREFIX; + struct device_route route; memset(&route, 0, sizeof(route)); route.flags = DEVADDR_INET6; @@ -642,12 +853,13 @@ 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; if (node_old && node_new) { // Move assignments and refresh addresses to update valid times - list_splice_init(&prefix_old->assignments, &prefix_new->assignments); + 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))) @@ -656,21 +868,21 @@ interface_update_prefix(struct vlist_tree *tree, // Set null-route to avoid routing loops system_add_route(NULL, &route); - INIT_LIST_HEAD(&prefix_new->assignments); - interface_update_prefix_assignments(prefix_new, true); + if (!prefix_new->iface || !prefix_new->iface->proto_ip.no_delegation) + interface_update_prefix_assignments(prefix_new, true); } else if (node_old) { - interface_update_prefix_assignments(prefix_old, false); - // Remove null-route + interface_update_prefix_assignments(prefix_old, false); system_del_route(NULL, &route); } if (node_old) { - list_del(&prefix_old->head); + if (prefix_old->head.next) + list_del(&prefix_old->head); free(prefix_old); } - if (node_new) + if (node_new && (!prefix_new->iface || !prefix_new->iface->proto_ip.no_delegation)) list_add(&prefix_new->head, &prefixes); } @@ -678,20 +890,26 @@ interface_update_prefix(struct vlist_tree *tree, struct device_prefix* interface_ip_add_device_prefix(struct interface *iface, struct in6_addr *addr, uint8_t length, time_t valid_until, time_t preferred_until, - struct in6_addr *excl_addr, uint8_t excl_length) + struct in6_addr *excl_addr, uint8_t excl_length, const char *pclass) { - struct device_prefix *prefix = calloc(1, sizeof(*prefix)); + if (!pclass) + pclass = (iface) ? iface->name : "local"; + + struct device_prefix *prefix = calloc(1, sizeof(*prefix) + strlen(pclass) + 1); prefix->length = length; prefix->addr = *addr; prefix->preferred_until = preferred_until; prefix->valid_until = valid_until; prefix->iface = iface; + INIT_LIST_HEAD(&prefix->assignments); if (excl_addr) { prefix->excl_addr = *excl_addr; prefix->excl_length = excl_length; } + strcpy(prefix->pclass, pclass); + if (iface) vlist_add(&iface->proto_ip.prefix, &prefix->node, &prefix->addr); else @@ -728,7 +946,7 @@ interface_ip_set_ula_prefix(const char *prefix) interface_update_prefix(NULL, NULL, &ula_prefix->node); ula_prefix = interface_ip_add_device_prefix(NULL, &addr, length, - 0, 0, NULL, 0); + 0, 0, NULL, 0, NULL); } } @@ -926,6 +1144,14 @@ void interface_ip_set_enabled(struct interface_ip_settings *ip, bool enabled) list_for_each_entry(a, &c->assignments, head) if (!strcmp(a->name, ip->iface->name)) interface_set_prefix_address(a, c, ip->iface, enabled); + + if (ip->iface && ip->iface->l3_dev.dev) { + set_ip_lo_policy(enabled, true, ip->iface); + 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"); + } } void