X-Git-Url: http://git.archive.openwrt.org/?p=project%2Fnetifd.git;a=blobdiff_plain;f=system-linux.c;h=8f46705d5f63670fa9c0eb9de2fa792c141e9dd1;hp=1fcf22fc0fe8042e9c423ddfe64450b48f95182a;hb=98ca67469da70accd710b14c28e77be2126170a8;hpb=b8f0ce8319a43d629c8de86df6951892b7e8d813

diff --git a/system-linux.c b/system-linux.c
index 1fcf22f..8f46705 100644
--- a/system-linux.c
+++ b/system-linux.c
@@ -1,3 +1,18 @@
+/*
+ * 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
+ * as published by the Free Software Foundation
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
 #define _GNU_SOURCE
 
 #include <sys/socket.h>
@@ -5,12 +20,27 @@
 #include <sys/stat.h>
 #include <sys/syscall.h>
 
+#include <net/if.h>
+#include <net/if_arp.h>
+
+#include <arpa/inet.h>
+#include <netinet/in.h>
+
 #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>
+
+#ifndef RTN_FAILED_POLICY
+#define RTN_FAILED_POLICY 12
+#endif
 
-#include <unistd.h>
 #include <string.h>
 #include <fcntl.h>
 #include <glob.h>
@@ -28,7 +58,7 @@
 struct event_socket {
 	struct uloop_fd uloop;
 	struct nl_sock *sock;
-	struct nl_cb *cb;
+	int bufsize;
 };
 
 static int sock_ioctl = -1;
@@ -37,11 +67,44 @@ static struct nl_sock *sock_rtnl = NULL;
 static int cb_rtnl_event(struct nl_msg *msg, void *arg);
 static void handle_hotplug_event(struct uloop_fd *u, unsigned int events);
 
+static char dev_buf[256];
+
 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 *
@@ -64,7 +127,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)
@@ -72,7 +135,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;
 }
 
@@ -80,14 +145,21 @@ 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);
+
+	// Disable sequence number checking on event sockets
+	nl_socket_disable_seq_check(ev->sock);
 
-	return create_raw_event_socket(ev, protocol, 0, handler_nl_event);
+	// 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;
 }
 
 int system_init(void)
@@ -96,7 +168,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);
@@ -107,7 +179,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
@@ -124,16 +196,14 @@ 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);
 }
 
 static void system_set_dev_sysctl(const char *path, const char *device, const char *val)
 {
-	static char buf[256];
-
-	snprintf(buf, sizeof(buf), path, val);
-	system_set_sysctl(buf, val);
+	snprintf(dev_buf, sizeof(dev_buf), path, device);
+	system_set_sysctl(dev_buf, val);
 }
 
 static void system_set_disable_ipv6(struct device *dev, const char *val)
@@ -141,6 +211,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)
 {
@@ -148,19 +256,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;
@@ -213,6 +321,9 @@ found:
 	if (dev->type != &simple_device_type)
 		return;
 
+	if (add && system_if_force_external(dev->ifname))
+		return;
+
 	device_set_present(dev, add);
 }
 
@@ -234,10 +345,15 @@ handle_hotplug_event(struct uloop_fd *u, unsigned int events)
 
 static int system_rtnl_call(struct nl_msg *msg)
 {
-	int s = -(nl_send_auto_complete(sock_rtnl, msg)
-			|| nl_wait_for_ack(sock_rtnl));
+	int ret;
+
+	ret = nl_send_auto_complete(sock_rtnl, msg);
 	nlmsg_free(msg);
-	return s;
+
+	if (ret < 0)
+		return ret;
+
+	return nl_wait_for_ack(sock_rtnl);
 }
 
 int system_bridge_delbr(struct device *bridge)
@@ -248,6 +364,8 @@ int system_bridge_delbr(struct device *bridge)
 static int system_bridge_if(const char *bridge, struct device *dev, int cmd, void *data)
 {
 	struct ifreq ifr;
+
+	memset(&ifr, 0, sizeof(ifr));
 	if (dev)
 		ifr.ifr_ifindex = dev->ifindex;
 	else
@@ -256,18 +374,6 @@ static int system_bridge_if(const char *bridge, struct device *dev, int cmd, voi
 	return ioctl(sock_ioctl, cmd, &ifr);
 }
 
-int system_bridge_addif(struct device *bridge, struct device *dev)
-{
-	system_set_disable_ipv6(dev, "1");
-	return system_bridge_if(bridge->ifname, dev, SIOCBRADDIF, NULL);
-}
-
-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);
-}
-
 static bool system_is_bridge(const char *name, char *buf, int buflen)
 {
 	struct stat st;
@@ -304,6 +410,22 @@ static char *system_get_bridge(const char *name, char *buf, int buflen)
 	return path + 1;
 }
 
+int system_bridge_addif(struct device *bridge, struct device *dev)
+{
+	char *oldbr;
+
+	oldbr = system_get_bridge(dev->ifname, dev_buf, sizeof(dev_buf));
+	if (oldbr && !strcmp(oldbr, bridge->ifname))
+		return 0;
+
+	return system_bridge_if(bridge->ifname, dev, SIOCBRADDIF, NULL);
+}
+
+int system_bridge_delif(struct device *bridge, struct device *dev)
+{
+	return system_bridge_if(bridge->ifname, dev, SIOCBRDELIF, NULL);
+}
+
 static int system_if_resolve(struct device *dev)
 {
 	struct ifreq ifr;
@@ -317,6 +439,8 @@ static int system_if_resolve(struct device *dev)
 static int system_if_flags(const char *ifname, unsigned add, unsigned rem)
 {
 	struct ifreq ifr;
+
+	memset(&ifr, 0, sizeof(ifr));
 	strncpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
 	ioctl(sock_ioctl, SIOCGIFFLAGS, &ifr);
 	ifr.ifr_flags |= add;
@@ -342,8 +466,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;
@@ -351,6 +480,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;
@@ -373,23 +507,34 @@ 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;
 	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;
 }
@@ -427,6 +572,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:
@@ -468,7 +614,7 @@ void system_if_clear_state(struct device *dev)
 	if (dev->external)
 		return;
 
-	dev->ifindex = system_if_resolve(dev);
+	device_set_ifindex(dev, system_if_resolve(dev));
 	if (!dev->ifindex)
 		return;
 
@@ -517,6 +663,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);
@@ -538,6 +688,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_INET };
+	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(msg, IFLA_IFNAME, IFNAMSIZ, macvlan->ifname);
+	nla_put_u32(msg, IFLA_LINK, ifindex);
+
+	if (!(linkinfo = nla_nest_start(msg, IFLA_LINKINFO)))
+		goto nla_put_failure;
+
+	nla_put(msg, IFLA_INFO_KIND, strlen("macvlan"), "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;
+}
+
+int system_macvlan_del(struct device *macvlan)
+{
+	struct nl_msg *msg;
+	struct ifinfomsg iim;
+
+	iim.ifi_family = AF_INET;
+	iim.ifi_index  = 0;
+
+	msg = nlmsg_alloc_simple(RTM_DELLINK, 0);
+
+	if (!msg)
+		return -1;
+
+	nlmsg_append(msg, &iim, sizeof(iim), 0);
+
+	nla_put(msg, IFLA_INFO_KIND, strlen("macvlan"), "macvlan");
+	nla_put(msg, IFLA_IFNAME, sizeof(macvlan->ifname), macvlan->ifname);
+
+	system_rtnl_call(msg);
+
+	return 0;
+}
+
 static int system_vlan(struct device *dev, int id)
 {
 	struct vlan_ioctl_args ifr = {
@@ -569,43 +806,153 @@ int system_vlan_del(struct device *dev)
 }
 
 static void
-system_if_apply_settings(struct device *dev)
+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));
-	if (dev->flags & DEV_OPT_MTU) {
-		ifr.ifr_mtu = dev->mtu;
-		ioctl(sock_ioctl, SIOCSIFMTU, &ifr);
+
+	if (ioctl(sock_ioctl, SIOCGIFMTU, &ifr) == 0) {
+		s->mtu = ifr.ifr_mtu;
+		s->flags |= DEV_OPT_MTU;
 	}
-	if (dev->flags & DEV_OPT_TXQUEUELEN) {
-		ifr.ifr_qlen = dev->txqueuelen;
-		ioctl(sock_ioctl, SIOCSIFTXQLEN, &ifr);
+
+	if (ioctl(sock_ioctl, SIOCGIFTXQLEN, &ifr) == 0) {
+		s->txqueuelen = ifr.ifr_qlen;
+		s->flags |= DEV_OPT_TXQUEUELEN;
 	}
-	if (dev->flags & DEV_OPT_MACADDR) {
-		memcpy(&ifr.ifr_hwaddr, dev->macaddr, sizeof(dev->macaddr));
-		ioctl(sock_ioctl, SIOCSIFHWADDR, &ifr);
+
+	if (ioctl(sock_ioctl, SIOCGIFHWADDR, &ifr) == 0) {
+		memcpy(s->macaddr, &ifr.ifr_hwaddr.sa_data, sizeof(s->macaddr));
+		s->flags |= DEV_OPT_MACADDR;
 	}
 
-	dev->ifindex = system_if_resolve(dev);
+	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, 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 & 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 & 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 & 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_apply_settings(dev);
+	system_if_get_settings(dev, &dev->orig_settings);
+	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);
 }
 
 int system_if_down(struct device *dev)
 {
-	return system_if_flags(dev->ifname, 0, IFF_UP);
+	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, 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 *
@@ -671,31 +1018,82 @@ 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;
 }
 
+/* Assume advertised flags == supported flags */
+static const struct {
+	uint32_t mask;
+	const char *name;
+} ethtool_link_modes[] = {
+	{ ADVERTISED_10baseT_Half, "10H" },
+	{ ADVERTISED_10baseT_Full, "10F" },
+	{ ADVERTISED_100baseT_Half, "100H" },
+	{ ADVERTISED_100baseT_Full, "100F" },
+	{ ADVERTISED_1000baseT_Half, "1000H" },
+	{ ADVERTISED_1000baseT_Full, "1000F" },
+};
+
+static void system_add_link_modes(struct blob_buf *b, __u32 mask)
+{
+	int i;
+	for (i = 0; i < ARRAY_SIZE(ethtool_link_modes); i++) {
+		if (mask & ethtool_link_modes[i].mask)
+			blobmsg_add_string(b, NULL, ethtool_link_modes[i].name);
+	}
+}
+
+bool
+system_if_force_external(const char *ifname)
+{
+	char buf[64];
+	struct stat s;
+
+	snprintf(buf, sizeof(buf), "/sys/class/net/%s/phy80211", ifname);
+	return stat(buf, &s) == 0;
+}
+
 int
 system_if_dump_info(struct device *dev, struct blob_buf *b)
 {
-	char buf[64];
-	int dir_fd, val = 0;
+	struct ethtool_cmd ecmd;
+	struct ifreq ifr;
+	char buf[64], *s;
+	void *c;
+	int dir_fd;
 
 	snprintf(buf, sizeof(buf), "/sys/class/net/%s", dev->ifname);
 	dir_fd = open(buf, O_DIRECTORY);
 
-	if (read_int_file(dir_fd, "carrier", &val))
-		blobmsg_add_u8(b, "link", !!val);
-	if (read_string_file(dir_fd, "address", buf, sizeof(buf)))
-		blobmsg_add_string(b, "macaddr", buf);
+	memset(&ecmd, 0, sizeof(ecmd));
+	memset(&ifr, 0, sizeof(ifr));
+	strcpy(ifr.ifr_name, dev->ifname);
+	ifr.ifr_data = (caddr_t) &ecmd;
+	ecmd.cmd = ETHTOOL_GSET;
+
+	if (ioctl(sock_ioctl, SIOCETHTOOL, &ifr) == 0) {
+		c = blobmsg_open_array(b, "link-advertising");
+		system_add_link_modes(b, ecmd.advertising);
+		blobmsg_close_array(b, c);
+
+		c = blobmsg_open_array(b, "link-supported");
+		system_add_link_modes(b, ecmd.supported);
+		blobmsg_close_array(b, c);
+
+		s = blobmsg_alloc_string_buffer(b, "speed", 8);
+		snprintf(s, 8, "%d%c", ethtool_cmd_speed(&ecmd),
+			ecmd.duplex == DUPLEX_HALF ? 'H' : 'F');
+		blobmsg_add_string_buffer(b);
+	}
 
 	close(dir_fd);
 	return 0;
@@ -716,7 +1114,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);
@@ -724,8 +1123,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;
@@ -733,7 +1132,9 @@ system_if_dump_stats(struct device *dev, struct blob_buf *b)
 
 static int system_addr(struct device *dev, struct device_addr *addr, int cmd)
 {
-	int alen = ((addr->flags & DEVADDR_FAMILY) == DEVADDR_INET4) ? 4 : 16;
+	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,
@@ -741,21 +1142,47 @@ 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;
 
-	dev = addr->device;
-	if (dev) {
-		if (!dev->ifindex)
-			return -1;
-
-		ifa.ifa_index = dev->ifindex;
-	}
-
-	msg = nlmsg_alloc_simple(cmd, 0);
+	msg = nlmsg_alloc_simple(cmd, flags);
 	if (!msg)
 		return -1;
 
 	nlmsg_append(msg, &ifa, sizeof(ifa), 0);
 	nla_put(msg, IFA_LOCAL, alen, &addr->addr);
+	if (v4) {
+		if (addr->broadcast)
+			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) {
+			int64_t preferred = addr->preferred_until - now;
+			if (preferred < 0)
+				preferred = 0;
+			else if (preferred > UINT32_MAX)
+				preferred = UINT32_MAX;
+
+			cinfo.ifa_prefered = preferred;
+		}
+
+		if (addr->valid_until) {
+			int64_t valid = addr->valid_until - now;
+			if (valid <= 0)
+				return -1;
+			else if (valid > UINT32_MAX)
+				valid = UINT32_MAX;
+
+			cinfo.ifa_valid = valid;
+		}
+
+		nla_put(msg, IFA_CACHEINFO, sizeof(cinfo), &cinfo);
+	}
+
 	return system_rtnl_call(msg);
 }
 
@@ -774,7 +1201,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;
@@ -787,25 +1213,27 @@ 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 = RTPROT_BOOT,
+		.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_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;
 
-	dev = route->device;
-	if (dev) {
-		if (!dev->ifindex)
-			return -1;
-
-		ifindex = dev->ifindex;
+		if (!dev) { // Add null-route
+			rtm.rtm_scope = RT_SCOPE_UNIVERSE;
+			rtm.rtm_type = RTN_UNREACHABLE;
+		}
 	}
 
 	msg = nlmsg_alloc_simple(cmd, flags);
@@ -817,11 +1245,20 @@ 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);
+
 	if (have_gw)
 		nla_put(msg, RTA_GATEWAY, alen, &route->nexthop);
 
-	if (route->flags & DEVADDR_DEVICE)
-		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);
 }
@@ -849,12 +1286,234 @@ 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_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 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;
+}
+
 time_t system_get_rtime(void)
 {
 	struct timespec ts;
@@ -868,3 +1527,159 @@ time_t system_get_rtime(void)
 
 	return 0;
 }
+
+#ifndef IP_DF
+#define IP_DF       0x4000
+#endif
+
+static int tunnel_ioctl(const char *name, int cmd, void *p)
+{
+	struct ifreq ifr;
+
+	memset(&ifr, 0, sizeof(ifr));
+	strncpy(ifr.ifr_name, name, sizeof(ifr.ifr_name));
+	ifr.ifr_ifru.ifru_data = p;
+	return ioctl(sock_ioctl, cmd, &ifr);
+}
+
+int system_del_ip_tunnel(const char *name)
+{
+	return tunnel_ioctl(name, SIOCDELTUNNEL, NULL);
+}
+
+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;
+}
+
+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);
+
+	blobmsg_parse(tunnel_attr_list.params, __TUNNEL_ATTR_MAX, tb,
+		blob_data(attr), blob_len(attr));
+
+	if (!(cur = tb[TUNNEL_ATTR_TYPE]))
+		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);
+		if (ttl > 255 || (!set_df && ttl))
+			return -EINVAL;
+	}
+
+	unsigned int link = 0;
+	if ((cur = tb[TUNNEL_ATTR_LINK])) {
+		struct interface *iface = vlist_find(&interfaces, blobmsg_data(cur), iface, node);
+		if (!iface)
+			return -EINVAL;
+
+		if (iface->l3_dev.dev)
+			link = iface->l3_dev.dev->ifindex;
+	}
+
+	if (!strcmp(str, "sit")) {
+		struct ip_tunnel_parm p = {
+			.link = link,
+			.iph = {
+				.version = 4,
+				.ihl = 5,
+				.frag_off = set_df ? htons(IP_DF) : 0,
+				.protocol = IPPROTO_IPV6,
+				.ttl = ttl
+			}
+		};
+
+		if ((cur = tb[TUNNEL_ATTR_LOCAL]) &&
+				inet_pton(AF_INET, blobmsg_data(cur), &p.iph.saddr) < 1)
+			return -EINVAL;
+
+		if ((cur = tb[TUNNEL_ATTR_REMOTE]) &&
+				inet_pton(AF_INET, blobmsg_data(cur), &p.iph.daddr) < 1)
+			return -EINVAL;
+
+		strncpy(p.name, name, sizeof(p.name));
+		if (tunnel_ioctl("sit0", SIOCADDTUNNEL, &p) < 0)
+			return -1;
+
+#ifdef SIOCADD6RD
+		if ((cur = tb[TUNNEL_ATTR_6RD_PREFIX])) {
+			unsigned int mask;
+			struct ip_tunnel_6rd p6;
+
+			memset(&p6, 0, sizeof(p6));
+
+			if (!parse_ip_and_netmask(AF_INET6, blobmsg_data(cur),
+						&p6.prefix, &mask) || mask > 128)
+				return -EINVAL;
+			p6.prefixlen = mask;
+
+			if ((cur = tb[TUNNEL_ATTR_6RD_RELAY_PREFIX])) {
+				if (!parse_ip_and_netmask(AF_INET, blobmsg_data(cur),
+							&p6.relay_prefix, &mask) || mask > 32)
+					return -EINVAL;
+				p6.relay_prefixlen = mask;
+			}
+
+			if (tunnel_ioctl(name, SIOCADD6RD, &p6) < 0) {
+				system_del_ip_tunnel(name);
+				return -1;
+			}
+		}
+#endif
+	} else if (!strcmp(str, "ipip6")) {
+		struct ip6_tnl_parm p = {
+			.link = link,
+			.proto = IPPROTO_IPIP,
+			.hop_limit = (ttl) ? ttl : 64,
+			.encap_limit = 4,
+		};
+
+		if ((cur = tb[TUNNEL_ATTR_LOCAL]) &&
+				inet_pton(AF_INET6, blobmsg_data(cur), &p.laddr) < 1)
+			return -EINVAL;
+
+		if ((cur = tb[TUNNEL_ATTR_REMOTE]) &&
+				inet_pton(AF_INET6, blobmsg_data(cur), &p.raddr) < 1)
+			return -EINVAL;
+
+		strncpy(p.name, name, sizeof(p.name));
+		if (tunnel_ioctl("ip6tnl0", SIOCADDTUNNEL, &p) < 0)
+			return -1;
+	} else
+		return -EINVAL;
+
+	return 0;
+}