X-Git-Url: http://git.archive.openwrt.org/?p=project%2Fnetifd.git;a=blobdiff_plain;f=system-linux.c;h=ea3a138d8543001c5dcb901fff38080134d3d235;hp=4299a6136260521d2537339f450d18da411e669c;hb=81b14db5ca47ae44efc5ccb982f16597873ab4ba;hpb=dc7ba66de87c2f624e906238e5a74b03da7c3b46

diff --git a/system-linux.c b/system-linux.c
index 4299a61..ea3a138 100644
--- a/system-linux.c
+++ b/system-linux.c
@@ -3,6 +3,7 @@
  * 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>
+ * Copyright (C) 2014 Gioacchino Mazzurco <gio@eigenlab.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
@@ -29,18 +30,19 @@
 #include <linux/rtnetlink.h>
 #include <linux/sockios.h>
 #include <linux/ip.h>
+#include <linux/if_link.h>
 #include <linux/if_vlan.h>
 #include <linux/if_bridge.h>
 #include <linux/if_tunnel.h>
 #include <linux/ip6_tunnel.h>
 #include <linux/ethtool.h>
 #include <linux/fib_rules.h>
+#include <linux/version.h>
 
 #ifndef RTN_FAILED_POLICY
 #define RTN_FAILED_POLICY 12
 #endif
 
-#include <unistd.h>
 #include <string.h>
 #include <fcntl.h>
 #include <glob.h>
@@ -58,7 +60,7 @@
 struct event_socket {
 	struct uloop_fd uloop;
 	struct nl_sock *sock;
-	struct nl_cb *cb;
+	int bufsize;
 };
 
 static int sock_ioctl = -1;
@@ -73,7 +75,38 @@ static void
 handler_nl_event(struct uloop_fd *u, unsigned int events)
 {
 	struct event_socket *ev = container_of(u, struct event_socket, uloop);
-	nl_recvmsgs(ev->sock, ev->cb);
+	int err;
+	socklen_t errlen = sizeof(err);
+
+	if (!u->error) {
+		nl_recvmsgs_default(ev->sock);
+		return;
+	}
+
+	if (getsockopt(u->fd, SOL_SOCKET, SO_ERROR, (void *)&err, &errlen))
+		goto abort;
+
+	switch(err) {
+	case ENOBUFS:
+		// Increase rx buffer size on netlink socket
+		ev->bufsize *= 2;
+		if (nl_socket_set_buffer_size(ev->sock, ev->bufsize, 0))
+			goto abort;
+
+		// Request full dump since some info got dropped
+		struct rtgenmsg msg = { .rtgen_family = AF_UNSPEC };
+		nl_send_simple(ev->sock, RTM_GETLINK, NLM_F_DUMP, &msg, sizeof(msg));
+		break;
+
+	default:
+		goto abort;
+	}
+	u->error = false;
+	return;
+
+abort:
+	uloop_fd_delete(&ev->uloop);
+	return;
 }
 
 static struct nl_sock *
@@ -96,7 +129,7 @@ create_socket(int protocol, int groups)
 
 static bool
 create_raw_event_socket(struct event_socket *ev, int protocol, int groups,
-			uloop_fd_handler cb)
+                        uloop_fd_handler cb, int flags)
 {
 	ev->sock = create_socket(protocol, groups);
 	if (!ev->sock)
@@ -104,7 +137,9 @@ create_raw_event_socket(struct event_socket *ev, int protocol, int groups,
 
 	ev->uloop.fd = nl_socket_get_fd(ev->sock);
 	ev->uloop.cb = cb;
-	uloop_fd_add(&ev->uloop, ULOOP_READ | ULOOP_EDGE_TRIGGER);
+	if (uloop_fd_add(&ev->uloop, ULOOP_READ|flags))
+		return false;
+
 	return true;
 }
 
@@ -112,14 +147,61 @@ static bool
 create_event_socket(struct event_socket *ev, int protocol,
 		    int (*cb)(struct nl_msg *msg, void *arg))
 {
-	// Prepare socket for link events
-	ev->cb = nl_cb_alloc(NL_CB_DEFAULT);
-	if (!ev->cb)
+	if (!create_raw_event_socket(ev, protocol, 0, handler_nl_event, ULOOP_ERROR_CB))
 		return false;
 
-	nl_cb_set(ev->cb, NL_CB_VALID, NL_CB_CUSTOM, cb, NULL);
+	// Install the valid custom callback handler
+	nl_socket_modify_cb(ev->sock, NL_CB_VALID, NL_CB_CUSTOM, cb, NULL);
 
-	return create_raw_event_socket(ev, protocol, 0, handler_nl_event);
+	// Disable sequence number checking on event sockets
+	nl_socket_disable_seq_check(ev->sock);
+
+	// Increase rx buffer size to 65K on event sockets
+	ev->bufsize = 65535;
+	if (nl_socket_set_buffer_size(ev->sock, ev->bufsize, 0))
+		return false;
+
+	return true;
+}
+
+static bool
+system_rtn_aton(const char *src, unsigned int *dst)
+{
+	char *e;
+	unsigned int n;
+
+	if (!strcmp(src, "local"))
+		n = RTN_LOCAL;
+	else if (!strcmp(src, "nat"))
+		n = RTN_NAT;
+	else if (!strcmp(src, "broadcast"))
+		n = RTN_BROADCAST;
+	else if (!strcmp(src, "anycast"))
+		n = RTN_ANYCAST;
+	else if (!strcmp(src, "multicast"))
+		n = RTN_MULTICAST;
+	else if (!strcmp(src, "prohibit"))
+		n = RTN_PROHIBIT;
+	else if (!strcmp(src, "unreachable"))
+		n = RTN_UNREACHABLE;
+	else if (!strcmp(src, "blackhole"))
+		n = RTN_BLACKHOLE;
+	else if (!strcmp(src, "xresolve"))
+		n = RTN_XRESOLVE;
+	else if (!strcmp(src, "unicast"))
+		n = RTN_UNICAST;
+	else if (!strcmp(src, "throw"))
+		n = RTN_THROW;
+	else if (!strcmp(src, "failed_policy"))
+		n = RTN_FAILED_POLICY;
+	else {
+		n = strtoul(src, &e, 0);
+		if (!e || *e || e == src || n > 255)
+			return false;
+	}
+
+	*dst = n;
+	return true;
 }
 
 int system_init(void)
@@ -128,7 +210,7 @@ int system_init(void)
 	static struct event_socket hotplug_event;
 
 	sock_ioctl = socket(AF_LOCAL, SOCK_DGRAM, 0);
-	fcntl(sock_ioctl, F_SETFD, fcntl(sock_ioctl, F_GETFD) | FD_CLOEXEC);
+	system_fd_set_cloexec(sock_ioctl);
 
 	// Prepare socket for routing / address control
 	sock_rtnl = create_socket(NETLINK_ROUTE, 0);
@@ -139,7 +221,7 @@ int system_init(void)
 		return -1;
 
 	if (!create_raw_event_socket(&hotplug_event, NETLINK_KOBJECT_UEVENT, 1,
-				     handle_hotplug_event))
+	                             handle_hotplug_event, 0))
 		return -1;
 
 	// Receive network link events form kernel
@@ -156,7 +238,7 @@ static void system_set_sysctl(const char *path, const char *val)
 	if (fd < 0)
 		return;
 
-	write(fd, val, strlen(val));
+	if (write(fd, val, strlen(val))) {}
 	close(fd);
 }
 
@@ -171,6 +253,44 @@ static void system_set_disable_ipv6(struct device *dev, const char *val)
 	system_set_dev_sysctl("/proc/sys/net/ipv6/conf/%s/disable_ipv6", dev->ifname, val);
 }
 
+static int system_get_sysctl(const char *path, char *buf, const size_t buf_sz)
+{
+	int fd = -1, ret = -1;
+
+	fd = open(path, O_RDONLY);
+	if (fd < 0)
+		goto out;
+
+	ssize_t len = read(fd, buf, buf_sz - 1);
+	if (len < 0)
+		goto out;
+
+	ret = buf[len] = 0;
+
+out:
+	if (fd >= 0)
+		close(fd);
+
+	return ret;
+}
+
+static int
+system_get_dev_sysctl(const char *path, const char *device, char *buf, const size_t buf_sz)
+{
+	snprintf(dev_buf, sizeof(dev_buf), path, device);
+	return system_get_sysctl(dev_buf, buf, buf_sz);
+}
+
+static int system_get_disable_ipv6(struct device *dev, char *buf, const size_t buf_sz)
+{
+	return system_get_dev_sysctl("/proc/sys/net/ipv6/conf/%s/disable_ipv6",
+			dev->ifname, buf, buf_sz);
+}
+
+#ifndef IFF_LOWER_UP
+#define IFF_LOWER_UP	0x10000
+#endif
+
 // Evaluate netlink messages
 static int cb_rtnl_event(struct nl_msg *msg, void *arg)
 {
@@ -178,19 +298,19 @@ static int cb_rtnl_event(struct nl_msg *msg, void *arg)
 	struct ifinfomsg *ifi = NLMSG_DATA(nh);
 	struct nlattr *nla[__IFLA_MAX];
 
-	if (nh->nlmsg_type != RTM_DELLINK && nh->nlmsg_type != RTM_NEWLINK)
+	if (nh->nlmsg_type != RTM_NEWLINK)
 		goto out;
 
 	nlmsg_parse(nh, sizeof(*ifi), nla, __IFLA_MAX - 1, NULL);
 	if (!nla[IFLA_IFNAME])
 		goto out;
 
-	struct device *dev = device_get(RTA_DATA(nla[IFLA_IFNAME]), false);
+	struct device *dev = device_get(nla_data(nla[IFLA_IFNAME]), false);
 	if (!dev)
 		goto out;
 
-	dev->ifindex = ifi->ifi_index;
-	/* TODO: parse link status */
+	device_set_ifindex(dev, ifi->ifi_index);
+	device_set_link(dev, ifi->ifi_flags & IFF_LOWER_UP ? true : false);
 
 out:
 	return 0;
@@ -332,21 +452,31 @@ static char *system_get_bridge(const char *name, char *buf, int buflen)
 	return path + 1;
 }
 
+static void system_bridge_set_wireless(const char *bridge, const char *dev)
+{
+	snprintf(dev_buf, sizeof(dev_buf),
+		 "/sys/devices/virtual/net/%s/brif/%s/multicast_to_unicast",
+		 bridge, dev);
+	system_set_sysctl(dev_buf, "1");
+}
+
 int system_bridge_addif(struct device *bridge, struct device *dev)
 {
 	char *oldbr;
+	int ret = 0;
 
-	system_set_disable_ipv6(dev, "1");
 	oldbr = system_get_bridge(dev->ifname, dev_buf, sizeof(dev_buf));
-	if (oldbr && !strcmp(oldbr, bridge->ifname))
-		return 0;
+	if (!oldbr || strcmp(oldbr, bridge->ifname) != 0)
+		ret = system_bridge_if(bridge->ifname, dev, SIOCBRADDIF, NULL);
 
-	return system_bridge_if(bridge->ifname, dev, SIOCBRADDIF, NULL);
+	if (dev->wireless)
+		system_bridge_set_wireless(bridge->ifname, dev->ifname);
+
+	return ret;
 }
 
 int system_bridge_delif(struct device *bridge, struct device *dev)
 {
-	system_set_disable_ipv6(dev, "0");
 	return system_bridge_if(bridge->ifname, dev, SIOCBRDELIF, NULL);
 }
 
@@ -456,8 +586,9 @@ static int cb_clear_event(struct nl_msg *msg, void *arg)
 	hdr->nlmsg_type = type;
 	hdr->nlmsg_flags = NLM_F_REQUEST;
 
-	if (!nl_send_auto_complete(sock_rtnl, clr->msg))
-		nl_wait_for_ack(sock_rtnl);
+	nl_socket_disable_auto_ack(sock_rtnl);
+	nl_send_auto_complete(sock_rtnl, clr->msg);
+	nl_socket_enable_auto_ack(sock_rtnl);
 
 	return NL_SKIP;
 }
@@ -534,11 +665,8 @@ void system_if_clear_state(struct device *dev)
 	static char buf[256];
 	char *bridge;
 
-	if (dev->external)
-		return;
-
-	dev->ifindex = system_if_resolve(dev);
-	if (!dev->ifindex)
+	device_set_ifindex(dev, system_if_resolve(dev));
+	if (dev->external || !dev->ifindex)
 		return;
 
 	system_if_flags(dev->ifname, 0, IFF_UP);
@@ -586,6 +714,9 @@ 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");
 
+	system_set_dev_sysctl("/sys/devices/virtual/net/%s/bridge/multicast_querier",
+		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);
@@ -611,6 +742,93 @@ int system_bridge_addbr(struct device *bridge, struct bridge_config *cfg)
 	return 0;
 }
 
+int system_macvlan_add(struct device *macvlan, struct device *dev, struct macvlan_config *cfg)
+{
+	struct nl_msg *msg;
+	struct nlattr *linkinfo, *data;
+	struct ifinfomsg iim = { .ifi_family = AF_UNSPEC, };
+	int ifindex = system_if_resolve(dev);
+	int i, rv;
+	static const struct {
+		const char *name;
+		enum macvlan_mode val;
+	} modes[] = {
+		{ "private", MACVLAN_MODE_PRIVATE },
+		{ "vepa", MACVLAN_MODE_VEPA },
+		{ "bridge", MACVLAN_MODE_BRIDGE },
+		{ "passthru", MACVLAN_MODE_PASSTHRU },
+	};
+
+	if (ifindex == 0)
+		return -ENOENT;
+
+	msg = nlmsg_alloc_simple(RTM_NEWLINK, NLM_F_REQUEST | NLM_F_CREATE | NLM_F_EXCL);
+
+	if (!msg)
+		return -1;
+
+	nlmsg_append(msg, &iim, sizeof(iim), 0);
+
+	if (cfg->flags & MACVLAN_OPT_MACADDR)
+		nla_put(msg, IFLA_ADDRESS, sizeof(cfg->macaddr), cfg->macaddr);
+	nla_put_string(msg, IFLA_IFNAME, macvlan->ifname);
+	nla_put_u32(msg, IFLA_LINK, ifindex);
+
+	if (!(linkinfo = nla_nest_start(msg, IFLA_LINKINFO)))
+		goto nla_put_failure;
+
+	nla_put_string(msg, IFLA_INFO_KIND, "macvlan");
+
+	if (!(data = nla_nest_start(msg, IFLA_INFO_DATA)))
+		goto nla_put_failure;
+
+	if (cfg->mode) {
+		for (i = 0; i < ARRAY_SIZE(modes); i++) {
+			if (strcmp(cfg->mode, modes[i].name) != 0)
+				continue;
+
+			nla_put_u32(msg, IFLA_MACVLAN_MODE, modes[i].val);
+			break;
+		}
+	}
+
+	nla_nest_end(msg, data);
+	nla_nest_end(msg, linkinfo);
+
+	rv = system_rtnl_call(msg);
+	if (rv)
+		D(SYSTEM, "Error adding macvlan '%s' over '%s': %d\n", macvlan->ifname, dev->ifname, rv);
+
+	return rv;
+
+nla_put_failure:
+	nlmsg_free(msg);
+	return -ENOMEM;
+}
+
+static int system_link_del(struct device *dev)
+{
+	struct nl_msg *msg;
+	struct ifinfomsg iim = {
+		.ifi_family = AF_UNSPEC,
+		.ifi_index = 0,
+	};
+
+	msg = nlmsg_alloc_simple(RTM_DELLINK, NLM_F_REQUEST);
+
+	if (!msg)
+		return -1;
+
+	nlmsg_append(msg, &iim, sizeof(iim), 0);
+	nla_put_string(msg, IFLA_IFNAME, dev->ifname);
+	return system_rtnl_call(msg);
+}
+
+int system_macvlan_del(struct device *macvlan)
+{
+	return system_link_del(macvlan);
+}
+
 static int system_vlan(struct device *dev, int id)
 {
 	struct vlan_ioctl_args ifr = {
@@ -641,10 +859,67 @@ int system_vlan_del(struct device *dev)
 	return system_vlan(dev, -1);
 }
 
+int system_vlandev_add(struct device *vlandev, struct device *dev, struct vlandev_config *cfg)
+{
+	struct nl_msg *msg;
+	struct nlattr *linkinfo, *data;
+	struct ifinfomsg iim = { .ifi_family = AF_UNSPEC };
+	int ifindex = system_if_resolve(dev);
+	int rv;
+
+	if (ifindex == 0)
+		return -ENOENT;
+
+	msg = nlmsg_alloc_simple(RTM_NEWLINK, NLM_F_REQUEST | NLM_F_CREATE | NLM_F_EXCL);
+
+	if (!msg)
+		return -1;
+
+	nlmsg_append(msg, &iim, sizeof(iim), 0);
+	nla_put_string(msg, IFLA_IFNAME, vlandev->ifname);
+	nla_put_u32(msg, IFLA_LINK, ifindex);
+	
+	if (!(linkinfo = nla_nest_start(msg, IFLA_LINKINFO)))
+		goto nla_put_failure;
+	
+	nla_put_string(msg, IFLA_INFO_KIND, "vlan");
+
+	if (!(data = nla_nest_start(msg, IFLA_INFO_DATA)))
+		goto nla_put_failure;
+
+	nla_put_u16(msg, IFLA_VLAN_ID, cfg->vid);
+
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,10,0)
+	nla_put_u16(msg, IFLA_VLAN_PROTOCOL, htons(cfg->proto));
+#else
+	if(cfg->proto == VLAN_PROTO_8021AD)
+		netifd_log_message(L_WARNING, "%s Your kernel is older than linux 3.10.0, 802.1ad is not supported defaulting to 802.1q", vlandev->type->name);
+#endif
+
+	nla_nest_end(msg, data);
+	nla_nest_end(msg, linkinfo);
+
+	rv = system_rtnl_call(msg);
+	if (rv)
+		D(SYSTEM, "Error adding vlandev '%s' over '%s': %d\n", vlandev->ifname, dev->ifname, rv);
+
+	return rv;
+
+nla_put_failure:
+	nlmsg_free(msg);
+	return -ENOMEM;
+}
+
+int system_vlandev_del(struct device *vlandev)
+{
+	return system_link_del(vlandev);
+}
+
 static void
 system_if_get_settings(struct device *dev, struct device_settings *s)
 {
 	struct ifreq ifr;
+	char buf[10];
 
 	memset(&ifr, 0, sizeof(ifr));
 	strncpy(ifr.ifr_name, dev->ifname, sizeof(ifr.ifr_name));
@@ -663,38 +938,48 @@ system_if_get_settings(struct device *dev, struct device_settings *s)
 		memcpy(s->macaddr, &ifr.ifr_hwaddr.sa_data, sizeof(s->macaddr));
 		s->flags |= DEV_OPT_MACADDR;
 	}
+
+	if (!system_get_disable_ipv6(dev, buf, sizeof(buf))) {
+		s->ipv6 = !strtoul(buf, NULL, 0);
+		s->flags |= DEV_OPT_IPV6;
+	}
 }
 
 void
-system_if_apply_settings(struct device *dev, struct device_settings *s)
+system_if_apply_settings(struct device *dev, struct device_settings *s, unsigned int apply_mask)
 {
 	struct ifreq ifr;
 
+	if (!apply_mask)
+		return;
+
 	memset(&ifr, 0, sizeof(ifr));
 	strncpy(ifr.ifr_name, dev->ifname, sizeof(ifr.ifr_name));
-	if (s->flags & DEV_OPT_MTU) {
+	if (s->flags & DEV_OPT_MTU & apply_mask) {
 		ifr.ifr_mtu = s->mtu;
 		if (ioctl(sock_ioctl, SIOCSIFMTU, &ifr) < 0)
 			s->flags &= ~DEV_OPT_MTU;
 	}
-	if (s->flags & DEV_OPT_TXQUEUELEN) {
+	if (s->flags & DEV_OPT_TXQUEUELEN & apply_mask) {
 		ifr.ifr_qlen = s->txqueuelen;
 		if (ioctl(sock_ioctl, SIOCSIFTXQLEN, &ifr) < 0)
 			s->flags &= ~DEV_OPT_TXQUEUELEN;
 	}
-	if ((s->flags & DEV_OPT_MACADDR) && !dev->external) {
+	if ((s->flags & DEV_OPT_MACADDR & apply_mask) && !dev->external) {
 		ifr.ifr_hwaddr.sa_family = ARPHRD_ETHER;
 		memcpy(&ifr.ifr_hwaddr.sa_data, s->macaddr, sizeof(s->macaddr));
 		if (ioctl(sock_ioctl, SIOCSIFHWADDR, &ifr) < 0)
 			s->flags &= ~DEV_OPT_MACADDR;
 	}
+	if (s->flags & DEV_OPT_IPV6 & apply_mask)
+		system_set_disable_ipv6(dev, s->ipv6 ? "0" : "1");
 }
 
 int system_if_up(struct device *dev)
 {
 	system_if_get_settings(dev, &dev->orig_settings);
-	system_if_apply_settings(dev, &dev->settings);
-	dev->ifindex = system_if_resolve(dev);
+	system_if_apply_settings(dev, &dev->settings, dev->settings.flags);
+	device_set_ifindex(dev, system_if_resolve(dev));
 	return system_if_flags(dev->ifname, IFF_UP, 0);
 }
 
@@ -702,14 +987,82 @@ int system_if_down(struct device *dev)
 {
 	int ret = system_if_flags(dev->ifname, 0, IFF_UP);
 	dev->orig_settings.flags &= dev->settings.flags;
-	system_if_apply_settings(dev, &dev->orig_settings);
+	system_if_apply_settings(dev, &dev->orig_settings, dev->orig_settings.flags);
 	return ret;
 }
 
+struct if_check_data {
+	struct device *dev;
+	int pending;
+	int ret;
+};
+
+static int cb_if_check_valid(struct nl_msg *msg, void *arg)
+{
+	struct nlmsghdr *nh = nlmsg_hdr(msg);
+	struct ifinfomsg *ifi = NLMSG_DATA(nh);
+	struct if_check_data *chk = (struct if_check_data *)arg;
+
+	if (nh->nlmsg_type != RTM_NEWLINK)
+		return NL_SKIP;
+
+	device_set_present(chk->dev, ifi->ifi_index > 0 ? true : false);
+	device_set_link(chk->dev, ifi->ifi_flags & IFF_LOWER_UP ? true : false);
+
+	return NL_OK;
+}
+
+static int cb_if_check_ack(struct nl_msg *msg, void *arg)
+{
+	struct if_check_data *chk = (struct if_check_data *)arg;
+	chk->pending = 0;
+	return NL_STOP;
+}
+
+static int cb_if_check_error(struct sockaddr_nl *nla, struct nlmsgerr *err, void *arg)
+{
+	struct if_check_data *chk = (struct if_check_data *)arg;
+
+	device_set_present(chk->dev, false);
+	device_set_link(chk->dev, false);
+	chk->pending = err->error;
+
+	return NL_STOP;
+}
+
 int system_if_check(struct device *dev)
 {
-	device_set_present(dev, (system_if_resolve(dev) > 0));
-	return 0;
+	struct nl_cb *cb = nl_cb_alloc(NL_CB_DEFAULT);
+	struct nl_msg *msg;
+	struct ifinfomsg ifi = {
+		.ifi_family = AF_UNSPEC,
+		.ifi_index = 0,
+	};
+	struct if_check_data chk = {
+		.dev = dev,
+		.pending = 1,
+	};
+	int ret = 1;
+
+	msg = nlmsg_alloc_simple(RTM_GETLINK, 0);
+	if (!msg || nlmsg_append(msg, &ifi, sizeof(ifi), 0) ||
+	    nla_put_string(msg, IFLA_IFNAME, dev->ifname))
+		goto out;
+
+	nl_cb_set(cb, NL_CB_VALID, NL_CB_CUSTOM, cb_if_check_valid, &chk);
+	nl_cb_set(cb, NL_CB_ACK, NL_CB_CUSTOM, cb_if_check_ack, &chk);
+	nl_cb_err(cb, NL_CB_CUSTOM, cb_if_check_error, &chk);
+
+	nl_send_auto_complete(sock_rtnl, msg);
+	while (chk.pending > 0)
+		nl_recvmsgs(sock_rtnl, cb);
+
+	nlmsg_free(msg);
+	ret = chk.pending;
+
+out:
+	nl_cb_put(cb);
+	return ret;
 }
 
 struct device *
@@ -827,14 +1180,10 @@ system_if_dump_info(struct device *dev, struct blob_buf *b)
 	char buf[64], *s;
 	void *c;
 	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_uint64_file(dir_fd, "carrier", &val))
-		blobmsg_add_u8(b, "link", !!val);
-
 	memset(&ecmd, 0, sizeof(ecmd));
 	memset(&ifr, 0, sizeof(ifr));
 	strcpy(ifr.ifr_name, dev->ifname);
@@ -971,19 +1320,18 @@ static int system_rt(struct device *dev, struct device_route *route, int cmd)
 			route->nexthop.in6.s6_addr32[2] ||
 			route->nexthop.in6.s6_addr32[3];
 
-	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_src_len = route->sourcemask,
 		.rtm_table = (table < 256) ? table : RT_TABLE_UNSPEC,
 		.rtm_protocol = (route->flags & DEVADDR_KERNEL) ? RTPROT_KERNEL : RTPROT_STATIC,
-		.rtm_scope = scope,
+		.rtm_scope = RT_SCOPE_NOWHERE,
 		.rtm_type = (cmd == RTM_DELROUTE) ? 0: RTN_UNICAST,
+		.rtm_flags = (route->flags & DEVROUTE_ONLINK) ? RTNH_F_ONLINK : 0,
 	};
 	struct nl_msg *msg;
 
@@ -994,6 +1342,23 @@ static int system_rt(struct device *dev, struct device_route *route, int cmd)
 			rtm.rtm_scope = RT_SCOPE_UNIVERSE;
 			rtm.rtm_type = RTN_UNREACHABLE;
 		}
+		else
+			rtm.rtm_scope = (have_gw) ? RT_SCOPE_UNIVERSE : RT_SCOPE_LINK;
+	}
+
+	if (route->flags & DEVROUTE_TYPE) {
+		rtm.rtm_type = route->type;
+		if (!(route->flags & (DEVROUTE_TABLE | DEVROUTE_SRCTABLE))) {
+			if (rtm.rtm_type == RTN_LOCAL || rtm.rtm_type == RTN_BROADCAST ||
+			    rtm.rtm_type == RTN_NAT || rtm.rtm_type == RTN_ANYCAST)
+				rtm.rtm_table = RT_TABLE_LOCAL;
+		}
+
+		if (rtm.rtm_type == RTN_LOCAL || rtm.rtm_type == RTN_NAT)
+			rtm.rtm_scope = RT_SCOPE_HOST;
+		else if (rtm.rtm_type == RTN_BROADCAST || rtm.rtm_type == RTN_MULTICAST ||
+			rtm.rtm_type == RTN_ANYCAST)
+			rtm.rtm_scope = RT_SCOPE_LINK;
 	}
 
 	msg = nlmsg_alloc_simple(cmd, flags);
@@ -1005,6 +1370,9 @@ static int system_rt(struct device *dev, struct device_route *route, int cmd)
 	if (route->mask)
 		nla_put(msg, RTA_DST, alen, &route->addr);
 
+	if (route->sourcemask)
+		nla_put(msg, RTA_SRC, alen, &route->source);
+
 	if (route->metric > 0)
 		nla_put_u32(msg, RTA_PRIORITY, route->metric);
 
@@ -1017,7 +1385,22 @@ static int system_rt(struct device *dev, struct device_route *route, int cmd)
 	if (table >= 256)
 		nla_put_u32(msg, RTA_TABLE, table);
 
+	if (route->flags & DEVROUTE_MTU) {
+		struct nlattr *metrics;
+
+		if (!(metrics = nla_nest_start(msg, RTA_METRICS)))
+			goto nla_put_failure;
+
+		nla_put_u32(msg, RTAX_MTU, route->mtu);
+
+		nla_nest_end(msg, metrics);
+	}
+
 	return system_rtnl_call(msg);
+
+nla_put_failure:
+	nlmsg_free(msg);
+	return -ENOMEM;
 }
 
 int system_add_route(struct device *dev, struct device_route *route)
@@ -1043,12 +1426,17 @@ int system_flush_routes(void)
 		if (fd < 0)
 			continue;
 
-		write(fd, "-1", 2);
+		if (write(fd, "-1", 2)) {}
 		close(fd);
 	}
 	return 0;
 }
 
+bool system_resolve_rt_type(const char *type, unsigned int *id)
+{
+	return system_rtn_aton(type, id);
+}
+
 bool system_resolve_rt_table(const char *name, unsigned int *id)
 {
 	FILE *f;
@@ -1091,14 +1479,15 @@ bool system_resolve_rt_table(const char *name, unsigned int *id)
 	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;
 }
 
+bool system_is_default_rt_table(unsigned int id)
+{
+	return (id == RT_TABLE_MAIN);
+}
+
 static int system_iprule(struct iprule *rule, int cmd)
 {
 	int alen = ((rule->flags & IPRULE_FAMILY) == IPRULE_INET4) ? 4 : 16;
@@ -1234,41 +1623,7 @@ int system_flush_iprules(void)
 
 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 if (!strcmp(action, "failed_policy"))
-		n = RTN_FAILED_POLICY;
-	else {
-		n = strtoul(action, &e, 0);
-		if (!e || *e || e == action || n > 255)
-			return false;
-	}
-
-	*id = n;
-	return true;
+	return system_rtn_aton(action, id);
 }
 
 time_t system_get_rtime(void)
@@ -1331,11 +1686,11 @@ out:
 	return ret;
 }
 
-
 int system_add_ip_tunnel(const char *name, struct blob_attr *attr)
 {
 	struct blob_attr *tb[__TUNNEL_ATTR_MAX];
 	struct blob_attr *cur;
+	bool set_df = true;
 	const char *str;
 
 	system_del_ip_tunnel(name);
@@ -1347,9 +1702,15 @@ int system_add_ip_tunnel(const char *name, struct blob_attr *attr)
 		return -EINVAL;
 	str = blobmsg_data(cur);
 
+	if ((cur = tb[TUNNEL_ATTR_DF]))
+		set_df = blobmsg_get_bool(cur);
+
 	unsigned int ttl = 0;
-	if ((cur = tb[TUNNEL_ATTR_TTL]) && (ttl = blobmsg_get_u32(cur)) > 255)
-		return -EINVAL;
+	if ((cur = tb[TUNNEL_ATTR_TTL])) {
+		ttl = blobmsg_get_u32(cur);
+		if (ttl > 255 || (!set_df && ttl))
+			return -EINVAL;
+	}
 
 	unsigned int link = 0;
 	if ((cur = tb[TUNNEL_ATTR_LINK])) {
@@ -1361,14 +1722,13 @@ int system_add_ip_tunnel(const char *name, struct blob_attr *attr)
 			link = iface->l3_dev.dev->ifindex;
 	}
 
-
 	if (!strcmp(str, "sit")) {
 		struct ip_tunnel_parm p = {
 			.link = link,
 			.iph = {
 				.version = 4,
 				.ihl = 5,
-				.frag_off = htons(IP_DF),
+				.frag_off = set_df ? htons(IP_DF) : 0,
 				.protocol = IPPROTO_IPV6,
 				.ttl = ttl
 			}
@@ -1412,25 +1772,109 @@ int system_add_ip_tunnel(const char *name, struct blob_attr *attr)
 		}
 #endif
 	} else if (!strcmp(str, "ipip6")) {
-		struct ip6_tnl_parm p = {
-			.link = link,
-			.proto = IPPROTO_IPIP,
-			.hop_limit = (ttl) ? ttl : 64,
-			.encap_limit = 4,
-		};
+		struct nl_msg *nlm = nlmsg_alloc_simple(RTM_NEWLINK,
+				NLM_F_REQUEST | NLM_F_REPLACE | NLM_F_CREATE);
+		struct ifinfomsg ifi = { .ifi_family = AF_UNSPEC };
+		int ret = 0;
 
-		if ((cur = tb[TUNNEL_ATTR_LOCAL]) &&
-				inet_pton(AF_INET6, blobmsg_data(cur), &p.laddr) < 1)
-			return -EINVAL;
+		if (!nlm)
+			return -1;
 
-		if ((cur = tb[TUNNEL_ATTR_REMOTE]) &&
-				inet_pton(AF_INET6, blobmsg_data(cur), &p.raddr) < 1)
-			return -EINVAL;
+		nlmsg_append(nlm, &ifi, sizeof(ifi), 0);
+		nla_put_string(nlm, IFLA_IFNAME, name);
 
-		strncpy(p.name, name, sizeof(p.name));
-		if (tunnel_ioctl("ip6tnl0", SIOCADDTUNNEL, &p) < 0)
-			return -1;
-	} else
+		if (link)
+			nla_put_u32(nlm, IFLA_LINK, link);
+
+		struct nlattr *linkinfo = nla_nest_start(nlm, IFLA_LINKINFO);
+		if (!linkinfo) {
+			ret = -ENOMEM;
+			goto failure;
+		}
+		nla_put_string(nlm, IFLA_INFO_KIND, "ip6tnl");
+		struct nlattr *infodata = nla_nest_start(nlm, IFLA_INFO_DATA);
+		if (!infodata) {
+			ret = -ENOMEM;
+			goto failure;
+		}
+
+		if (link)
+			nla_put_u32(nlm, IFLA_IPTUN_LINK, link);
+
+		nla_put_u8(nlm, IFLA_IPTUN_PROTO, IPPROTO_IPIP);
+		nla_put_u8(nlm, IFLA_IPTUN_TTL, (ttl) ? ttl : 64);
+		nla_put_u8(nlm, IFLA_IPTUN_ENCAP_LIMIT, 4);
+
+		struct in6_addr in6buf;
+		if ((cur = tb[TUNNEL_ATTR_LOCAL])) {
+			if (inet_pton(AF_INET6, blobmsg_data(cur), &in6buf) < 1) {
+				ret = -EINVAL;
+				goto failure;
+			}
+			nla_put(nlm, IFLA_IPTUN_LOCAL, sizeof(in6buf), &in6buf);
+		}
+
+		if ((cur = tb[TUNNEL_ATTR_REMOTE])) {
+			if (inet_pton(AF_INET6, blobmsg_data(cur), &in6buf) < 1) {
+				ret = -EINVAL;
+				goto failure;
+			}
+			nla_put(nlm, IFLA_IPTUN_REMOTE, sizeof(in6buf), &in6buf);
+		}
+
+#ifdef IFLA_IPTUN_FMR_MAX
+		if ((cur = tb[TUNNEL_ATTR_FMRS])) {
+			struct nlattr *fmrs = nla_nest_start(nlm, IFLA_IPTUN_FMRS);
+
+			struct blob_attr *fmr;
+			unsigned rem, fmrcnt = 0;
+			blobmsg_for_each_attr(fmr, cur, rem) {
+				if (blobmsg_type(fmr) != BLOBMSG_TYPE_STRING)
+					continue;
+
+				unsigned ip4len, ip6len, ealen, offset = 6;
+				char ip6buf[48];
+				char ip4buf[16];
+
+				if (sscanf(blobmsg_get_string(fmr), "%47[^/]/%u,%15[^/]/%u,%u,%u",
+						ip6buf, &ip6len, ip4buf, &ip4len, &ealen, &offset) < 5) {
+					ret = -EINVAL;
+					goto failure;
+				}
+
+				struct in6_addr ip6prefix;
+				struct in_addr ip4prefix;
+				if (inet_pton(AF_INET6, ip6buf, &ip6prefix) != 1 ||
+						inet_pton(AF_INET, ip4buf, &ip4prefix) != 1) {
+					ret = -EINVAL;
+					goto failure;
+				}
+
+				struct nlattr *rule = nla_nest_start(nlm, ++fmrcnt);
+
+				nla_put(nlm, IFLA_IPTUN_FMR_IP6_PREFIX, sizeof(ip6prefix), &ip6prefix);
+				nla_put(nlm, IFLA_IPTUN_FMR_IP4_PREFIX, sizeof(ip4prefix), &ip4prefix);
+				nla_put_u8(nlm, IFLA_IPTUN_FMR_IP6_PREFIX_LEN, ip6len);
+				nla_put_u8(nlm, IFLA_IPTUN_FMR_IP4_PREFIX_LEN, ip4len);
+				nla_put_u8(nlm, IFLA_IPTUN_FMR_EA_LEN, ealen);
+				nla_put_u8(nlm, IFLA_IPTUN_FMR_OFFSET, offset);
+
+				nla_nest_end(nlm, rule);
+			}
+
+			nla_nest_end(nlm, fmrs);
+		}
+#endif
+
+		nla_nest_end(nlm, infodata);
+		nla_nest_end(nlm, linkinfo);
+
+		return system_rtnl_call(nlm);
+failure:
+		nlmsg_free(nlm);
+		return ret;
+	}
+	else
 		return -EINVAL;
 
 	return 0;