X-Git-Url: https://git.archive.openwrt.org/?p=project%2Fnetifd.git;a=blobdiff_plain;f=system-linux.c;h=4401f784dde3d8e0753fdef9f862111d773ac7e1;hp=b3b58bea557df328f54f53e39fd06575a086a1a5;hb=587655b45085fcfc9c575792640c21c6ffb24f42;hpb=e4285cdc1bda303b01bbf2a43340d3f40f477820

diff --git a/system-linux.c b/system-linux.c
index b3b58be..4401f78 100644
--- a/system-linux.c
+++ b/system-linux.c
@@ -1,6 +1,8 @@
 /*
  * netifd - network interface daemon
  * Copyright (C) 2012 Felix Fietkau <nbd@openwrt.org>
+ * Copyright (C) 2013 Jo-Philipp Wich <jow@openwrt.org>
+ * Copyright (C) 2013 Steven Barth <steven@midlink.org>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2
@@ -31,6 +33,7 @@
 #include <linux/if_bridge.h>
 #include <linux/if_tunnel.h>
 #include <linux/ethtool.h>
+#include <linux/fib_rules.h>
 
 #include <unistd.h>
 #include <string.h>
@@ -382,8 +385,13 @@ static bool check_ifaddr(struct nlmsghdr *hdr, int ifindex)
 
 static bool check_route(struct nlmsghdr *hdr, int ifindex)
 {
+	struct rtmsg *r = NLMSG_DATA(hdr);
 	struct nlattr *tb[__RTA_MAX];
 
+	if (r->rtm_protocol == RTPROT_KERNEL &&
+	    r->rtm_family == AF_INET6)
+		return false;
+
 	nlmsg_parse(hdr, sizeof(struct rtmsg), tb, __RTA_MAX - 1, NULL);
 	if (!tb[RTA_OIF])
 		return false;
@@ -391,6 +399,11 @@ static bool check_route(struct nlmsghdr *hdr, int ifindex)
 	return *(int *)RTA_DATA(tb[RTA_OIF]) == ifindex;
 }
 
+static bool check_rule(struct nlmsghdr *hdr, int ifindex)
+{
+	return true;
+}
+
 static int cb_clear_event(struct nl_msg *msg, void *arg)
 {
 	struct clear_data *clr = arg;
@@ -413,16 +426,26 @@ static int cb_clear_event(struct nl_msg *msg, void *arg)
 
 		cb = check_route;
 		break;
+	case RTM_GETRULE:
+		type = RTM_DELRULE;
+		if (hdr->nlmsg_type != RTM_NEWRULE)
+			return NL_SKIP;
+
+		cb = check_rule;
+		break;
 	default:
 		return NL_SKIP;
 	}
 
-	if (!cb(hdr, clr->dev->ifindex))
+	if (!cb(hdr, clr->dev ? clr->dev->ifindex : 0))
 		return NL_SKIP;
 
-	D(SYSTEM, "Remove %s from device %s\n",
-	  type == RTM_DELADDR ? "an address" : "a route",
-	  clr->dev->ifname);
+	if (type == RTM_DELRULE)
+		D(SYSTEM, "Remove a rule\n");
+	else
+		D(SYSTEM, "Remove %s from device %s\n",
+		  type == RTM_DELADDR ? "an address" : "a route",
+		  clr->dev->ifname);
 	memcpy(nlmsg_hdr(clr->msg), hdr, hdr->nlmsg_len);
 	hdr = nlmsg_hdr(clr->msg);
 	hdr->nlmsg_type = type;
@@ -467,6 +490,7 @@ system_if_clear_entries(struct device *dev, int type, int af)
 	clr.type = type;
 	switch (type) {
 	case RTM_GETADDR:
+	case RTM_GETRULE:
 		clr.size = sizeof(struct rtgenmsg);
 		break;
 	case RTM_GETROUTE:
@@ -557,6 +581,10 @@ int system_bridge_addbr(struct device *bridge, struct bridge_config *cfg)
 	system_set_dev_sysctl("/sys/devices/virtual/net/%s/bridge/multicast_snooping",
 		bridge->ifname, cfg->igmp_snoop ? "1" : "0");
 
+	args[0] = BRCTL_SET_BRIDGE_PRIORITY;
+	args[1] = cfg->priority;
+	system_bridge_if(bridge->ifname, NULL, SIOCDEVPRIVATE, &args);
+
 	if (cfg->flags & BRIDGE_OPT_AGEING_TIME) {
 		args[0] = BRCTL_SET_AGEING_TIME;
 		args[1] = sec_to_jiffies(cfg->ageing_time);
@@ -742,14 +770,14 @@ retry:
 }
 
 static bool
-read_int_file(int dir_fd, const char *file, int *val)
+read_uint64_file(int dir_fd, const char *file, uint64_t *val)
 {
 	char buf[64];
 	bool ret = false;
 
 	ret = read_string_file(dir_fd, file, buf, sizeof(buf));
 	if (ret)
-		*val = strtoul(buf, NULL, 0);
+		*val = strtoull(buf, NULL, 0);
 
 	return ret;
 }
@@ -793,12 +821,13 @@ system_if_dump_info(struct device *dev, struct blob_buf *b)
 	struct ifreq ifr;
 	char buf[64], *s;
 	void *c;
-	int dir_fd, val = 0;
+	int dir_fd;
+	uint64_t val = 0;
 
 	snprintf(buf, sizeof(buf), "/sys/class/net/%s", dev->ifname);
 	dir_fd = open(buf, O_DIRECTORY);
 
-	if (read_int_file(dir_fd, "carrier", &val))
+	if (read_uint64_file(dir_fd, "carrier", &val))
 		blobmsg_add_u8(b, "link", !!val);
 
 	memset(&ecmd, 0, sizeof(ecmd));
@@ -841,7 +870,8 @@ system_if_dump_stats(struct device *dev, struct blob_buf *b)
 	};
 	char buf[64];
 	int stats_dir;
-	int i, val = 0;
+	int i;
+	uint64_t val = 0;
 
 	snprintf(buf, sizeof(buf), "/sys/class/net/%s/statistics", dev->ifname);
 	stats_dir = open(buf, O_DIRECTORY);
@@ -849,8 +879,8 @@ system_if_dump_stats(struct device *dev, struct blob_buf *b)
 		return -1;
 
 	for (i = 0; i < ARRAY_SIZE(counters); i++)
-		if (read_int_file(stats_dir, counters[i], &val))
-			blobmsg_add_u32(b, counters[i], val);
+		if (read_uint64_file(stats_dir, counters[i], &val))
+			blobmsg_add_u64(b, counters[i], val);
 
 	close(stats_dir);
 	return 0;
@@ -860,6 +890,7 @@ static int system_addr(struct device *dev, struct device_addr *addr, int cmd)
 {
 	bool v4 = ((addr->flags & DEVADDR_FAMILY) == DEVADDR_INET4);
 	int alen = v4 ? 4 : 16;
+	unsigned int flags = 0;
 	struct ifaddrmsg ifa = {
 		.ifa_family = (alen == 4) ? AF_INET : AF_INET6,
 		.ifa_prefixlen = addr->mask,
@@ -867,8 +898,10 @@ static int system_addr(struct device *dev, struct device_addr *addr, int cmd)
 	};
 
 	struct nl_msg *msg;
+	if (cmd == RTM_NEWADDR)
+		flags |= NLM_F_CREATE | NLM_F_REPLACE;
 
-	msg = nlmsg_alloc_simple(cmd, 0);
+	msg = nlmsg_alloc_simple(cmd, flags);
 	if (!msg)
 		return -1;
 
@@ -879,6 +912,27 @@ static int system_addr(struct device *dev, struct device_addr *addr, int cmd)
 			nla_put_u32(msg, IFA_BROADCAST, addr->broadcast);
 		if (addr->point_to_point)
 			nla_put_u32(msg, IFA_ADDRESS, addr->point_to_point);
+	} else {
+		time_t now = system_get_rtime();
+		struct ifa_cacheinfo cinfo = {0xffffffffU, 0xffffffffU, 0, 0};
+
+		if (addr->preferred_until) {
+			int preferred = addr->preferred_until - now;
+			if (preferred < 0)
+				preferred = 0;
+
+			cinfo.ifa_prefered = preferred;
+		}
+
+		if (addr->valid_until) {
+			int valid = addr->valid_until - now;
+			if (valid <= 0)
+				return -1;
+
+			cinfo.ifa_valid = valid;
+		}
+
+		nla_put(msg, IFA_CACHEINFO, sizeof(cinfo), &cinfo);
 	}
 
 	return system_rtnl_call(msg);
@@ -899,7 +953,6 @@ static int system_rt(struct device *dev, struct device_route *route, int cmd)
 	int alen = ((route->flags & DEVADDR_FAMILY) == DEVADDR_INET4) ? 4 : 16;
 	bool have_gw;
 	unsigned int flags = 0;
-	int ifindex = dev->ifindex;
 
 	if (alen == 4)
 		have_gw = !!route->nexthop.in.s_addr;
@@ -912,19 +965,28 @@ static int system_rt(struct device *dev, struct device_route *route, int cmd)
 	unsigned char scope = (cmd == RTM_DELROUTE) ? RT_SCOPE_NOWHERE :
 			(have_gw) ? RT_SCOPE_UNIVERSE : RT_SCOPE_LINK;
 
+	unsigned int table = (route->flags & (DEVROUTE_TABLE | DEVROUTE_SRCTABLE))
+			? route->table : RT_TABLE_MAIN;
+
 	struct rtmsg rtm = {
 		.rtm_family = (alen == 4) ? AF_INET : AF_INET6,
 		.rtm_dst_len = route->mask,
-		.rtm_table = RT_TABLE_MAIN,
-		.rtm_protocol = (route->flags & DEVADDR_KERNEL) ? RTPROT_KERNEL : RTPROT_BOOT,
+		.rtm_table = (table < 256) ? table : RT_TABLE_UNSPEC,
+		.rtm_protocol = (route->flags & DEVADDR_KERNEL) ? RTPROT_KERNEL : RTPROT_STATIC,
 		.rtm_scope = scope,
 		.rtm_type = (cmd == RTM_DELROUTE) ? 0: RTN_UNICAST,
 	};
 	struct nl_msg *msg;
 
-	if (cmd == RTM_NEWROUTE)
+	if (cmd == RTM_NEWROUTE) {
 		flags |= NLM_F_CREATE | NLM_F_REPLACE;
 
+		if (!dev) { // Add null-route
+			rtm.rtm_scope = RT_SCOPE_UNIVERSE;
+			rtm.rtm_type = RTN_UNREACHABLE;
+		}
+	}
+
 	msg = nlmsg_alloc_simple(cmd, flags);
 	if (!msg)
 		return -1;
@@ -940,7 +1002,11 @@ static int system_rt(struct device *dev, struct device_route *route, int cmd)
 	if (have_gw)
 		nla_put(msg, RTA_GATEWAY, alen, &route->nexthop);
 
-	nla_put_u32(msg, RTA_OIF, ifindex);
+	if (dev)
+		nla_put_u32(msg, RTA_OIF, dev->ifindex);
+
+	if (table >= 256)
+		nla_put_u32(msg, RTA_TABLE, table);
 
 	return system_rtnl_call(msg);
 }
@@ -974,6 +1040,226 @@ int system_flush_routes(void)
 	return 0;
 }
 
+bool system_resolve_rt_table(const char *name, unsigned int *id)
+{
+	FILE *f;
+	char *e, buf[128];
+	unsigned int n, table = RT_TABLE_UNSPEC;
+
+	/* first try to parse table as number */
+	if ((n = strtoul(name, &e, 0)) > 0 && !*e)
+		table = n;
+
+	/* handle well known aliases */
+	else if (!strcmp(name, "default"))
+		table = RT_TABLE_DEFAULT;
+	else if (!strcmp(name, "main"))
+		table = RT_TABLE_MAIN;
+	else if (!strcmp(name, "local"))
+		table = RT_TABLE_LOCAL;
+
+	/* try to look up name in /etc/iproute2/rt_tables */
+	else if ((f = fopen("/etc/iproute2/rt_tables", "r")) != NULL)
+	{
+		while (fgets(buf, sizeof(buf) - 1, f) != NULL)
+		{
+			if ((e = strtok(buf, " \t\n")) == NULL || *e == '#')
+				continue;
+
+			n = strtoul(e, NULL, 10);
+			e = strtok(NULL, " \t\n");
+
+			if (e && !strcmp(e, name))
+			{
+				table = n;
+				break;
+			}
+		}
+
+		fclose(f);
+	}
+
+	if (table == RT_TABLE_UNSPEC)
+		return false;
+
+	/* do not consider main table special */
+	if (table == RT_TABLE_MAIN)
+		table = RT_TABLE_UNSPEC;
+
+	*id = table;
+	return true;
+}
+
+static int system_iprule(struct iprule *rule, int cmd)
+{
+	int alen = ((rule->flags & IPRULE_FAMILY) == IPRULE_INET4) ? 4 : 16;
+
+	struct nl_msg *msg;
+	struct rtmsg rtm = {
+		.rtm_family = (alen == 4) ? AF_INET : AF_INET6,
+		.rtm_protocol = RTPROT_STATIC,
+		.rtm_scope = RT_SCOPE_UNIVERSE,
+		.rtm_table = RT_TABLE_UNSPEC,
+		.rtm_type = RTN_UNSPEC,
+		.rtm_flags = 0,
+	};
+
+	if (cmd == RTM_NEWRULE) {
+		rtm.rtm_type = RTN_UNICAST;
+		rtm.rtm_flags |= NLM_F_REPLACE | NLM_F_EXCL;
+	}
+
+	if (rule->invert)
+		rtm.rtm_flags |= FIB_RULE_INVERT;
+
+	if (rule->flags & IPRULE_SRC)
+		rtm.rtm_src_len = rule->src_mask;
+
+	if (rule->flags & IPRULE_DEST)
+		rtm.rtm_dst_len = rule->dest_mask;
+
+	if (rule->flags & IPRULE_TOS)
+		rtm.rtm_tos = rule->tos;
+
+	if (rule->flags & IPRULE_LOOKUP) {
+		if (rule->lookup < 256)
+			rtm.rtm_table = rule->lookup;
+	}
+
+	if (rule->flags & IPRULE_ACTION)
+		rtm.rtm_type = rule->action;
+	else if (rule->flags & IPRULE_GOTO)
+		rtm.rtm_type = FR_ACT_GOTO;
+	else if (!(rule->flags & (IPRULE_LOOKUP | IPRULE_ACTION | IPRULE_GOTO)))
+		rtm.rtm_type = FR_ACT_NOP;
+
+	msg = nlmsg_alloc_simple(cmd, NLM_F_REQUEST);
+
+	if (!msg)
+		return -1;
+
+	nlmsg_append(msg, &rtm, sizeof(rtm), 0);
+
+	if (rule->flags & IPRULE_IN)
+		nla_put(msg, FRA_IFNAME, strlen(rule->in_dev) + 1, rule->in_dev);
+
+	if (rule->flags & IPRULE_OUT)
+		nla_put(msg, FRA_OIFNAME, strlen(rule->out_dev) + 1, rule->out_dev);
+
+	if (rule->flags & IPRULE_SRC)
+		nla_put(msg, FRA_SRC, alen, &rule->src_addr);
+
+	if (rule->flags & IPRULE_DEST)
+		nla_put(msg, FRA_DST, alen, &rule->dest_addr);
+
+	if (rule->flags & IPRULE_PRIORITY)
+		nla_put_u32(msg, FRA_PRIORITY, rule->priority);
+	else if (cmd == RTM_NEWRULE)
+		nla_put_u32(msg, FRA_PRIORITY, rule->order);
+
+	if (rule->flags & IPRULE_FWMARK)
+		nla_put_u32(msg, FRA_FWMARK, rule->fwmark);
+
+	if (rule->flags & IPRULE_FWMASK)
+		nla_put_u32(msg, FRA_FWMASK, rule->fwmask);
+
+	if (rule->flags & IPRULE_LOOKUP) {
+		if (rule->lookup >= 256)
+			nla_put_u32(msg, FRA_TABLE, rule->lookup);
+	}
+
+	if (rule->flags & IPRULE_GOTO)
+		nla_put_u32(msg, FRA_GOTO, rule->gotoid);
+
+	return system_rtnl_call(msg);
+}
+
+int system_add_iprule(struct iprule *rule)
+{
+	return system_iprule(rule, RTM_NEWRULE);
+}
+
+int system_del_iprule(struct iprule *rule)
+{
+	return system_iprule(rule, RTM_DELRULE);
+}
+
+int system_flush_iprules(void)
+{
+	int rv = 0;
+	struct iprule rule;
+
+	system_if_clear_entries(NULL, RTM_GETRULE, AF_INET);
+	system_if_clear_entries(NULL, RTM_GETRULE, AF_INET6);
+
+	memset(&rule, 0, sizeof(rule));
+
+
+	rule.flags = IPRULE_INET4 | IPRULE_PRIORITY | IPRULE_LOOKUP;
+
+	rule.priority = 0;
+	rule.lookup = RT_TABLE_LOCAL;
+	rv |= system_iprule(&rule, RTM_NEWRULE);
+
+	rule.priority = 32766;
+	rule.lookup = RT_TABLE_MAIN;
+	rv |= system_iprule(&rule, RTM_NEWRULE);
+
+	rule.priority = 32767;
+	rule.lookup = RT_TABLE_DEFAULT;
+	rv |= system_iprule(&rule, RTM_NEWRULE);
+
+
+	rule.flags = IPRULE_INET6 | IPRULE_PRIORITY | IPRULE_LOOKUP;
+
+	rule.priority = 0;
+	rule.lookup = RT_TABLE_LOCAL;
+	rv |= system_iprule(&rule, RTM_NEWRULE);
+
+	rule.priority = 32766;
+	rule.lookup = RT_TABLE_MAIN;
+	rv |= system_iprule(&rule, RTM_NEWRULE);
+
+	return rv;
+}
+
+bool system_resolve_iprule_action(const char *action, unsigned int *id)
+{
+	char *e;
+	unsigned int n;
+
+	if (!strcmp(action, "local"))
+		n = RTN_LOCAL;
+	else if (!strcmp(action, "nat"))
+		n = RTN_NAT;
+	else if (!strcmp(action, "broadcast"))
+		n = RTN_BROADCAST;
+	else if (!strcmp(action, "anycast"))
+		n = RTN_ANYCAST;
+	else if (!strcmp(action, "multicast"))
+		n = RTN_MULTICAST;
+	else if (!strcmp(action, "prohibit"))
+		n = RTN_PROHIBIT;
+	else if (!strcmp(action, "unreachable"))
+		n = RTN_UNREACHABLE;
+	else if (!strcmp(action, "blackhole"))
+		n = RTN_BLACKHOLE;
+	else if (!strcmp(action, "xresolve"))
+		n = RTN_XRESOLVE;
+	else if (!strcmp(action, "unicast"))
+		n = RTN_UNICAST;
+	else if (!strcmp(action, "throw"))
+		n = RTN_THROW;
+	else {
+		n = strtoul(action, &e, 0);
+		if (!e || *e || e == action || n > 255)
+			return false;
+	}
+
+	*id = n;
+	return true;
+}
+
 time_t system_get_rtime(void)
 {
 	struct timespec ts;
@@ -1018,6 +1304,33 @@ int system_del_ip_tunnel(const char *name)
 	return tunnel_ioctl(name, SIOCDELTUNNEL, &p);
 }
 
+int system_update_ipv6_mtu(struct device *dev, int mtu)
+{
+	int ret = -1;
+	char buf[64];
+	snprintf(buf, sizeof(buf), "/proc/sys/net/ipv6/conf/%s/mtu",
+			dev->ifname);
+
+	int fd = open(buf, O_RDWR);
+	ssize_t len = read(fd, buf, sizeof(buf) - 1);
+	if (len < 0)
+		goto out;
+
+	buf[len] = 0;
+	ret = atoi(buf);
+
+	if (!mtu || ret <= mtu)
+		goto out;
+
+	lseek(fd, 0, SEEK_SET);
+	if (write(fd, buf, snprintf(buf, sizeof(buf), "%i", mtu)) <= 0)
+		ret = -1;
+
+out:
+	close(fd);
+	return ret;
+}
+
 static int parse_ipaddr(struct blob_attr *attr, __be32 *addr)
 {
 	if (!attr)