2 * netifd - network interface daemon
3 * Copyright (C) 2012 Felix Fietkau <nbd@openwrt.org>
4 * Copyright (C) 2013 Jo-Philipp Wich <jow@openwrt.org>
5 * Copyright (C) 2013 Steven Barth <steven@midlink.org>
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2
9 * as published by the Free Software Foundation
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
18 #include <sys/socket.h>
19 #include <sys/ioctl.h>
21 #include <sys/syscall.h>
24 #include <net/if_arp.h>
26 #include <arpa/inet.h>
27 #include <netinet/in.h>
29 #include <linux/rtnetlink.h>
30 #include <linux/sockios.h>
32 #include <linux/if_link.h>
33 #include <linux/if_vlan.h>
34 #include <linux/if_bridge.h>
35 #include <linux/if_tunnel.h>
36 #include <linux/ip6_tunnel.h>
37 #include <linux/ethtool.h>
38 #include <linux/fib_rules.h>
40 #ifndef RTN_FAILED_POLICY
41 #define RTN_FAILED_POLICY 12
49 #include <netlink/msg.h>
50 #include <netlink/attr.h>
51 #include <netlink/socket.h>
52 #include <libubox/uloop.h>
59 struct uloop_fd uloop;
64 static int sock_ioctl = -1;
65 static struct nl_sock *sock_rtnl = NULL;
67 static int cb_rtnl_event(struct nl_msg *msg, void *arg);
68 static void handle_hotplug_event(struct uloop_fd *u, unsigned int events);
70 static char dev_buf[256];
73 handler_nl_event(struct uloop_fd *u, unsigned int events)
75 struct event_socket *ev = container_of(u, struct event_socket, uloop);
77 socklen_t errlen = sizeof(err);
80 nl_recvmsgs_default(ev->sock);
84 if (getsockopt(u->fd, SOL_SOCKET, SO_ERROR, (void *)&err, &errlen))
89 // Increase rx buffer size on netlink socket
91 if (nl_socket_set_buffer_size(ev->sock, ev->bufsize, 0))
94 // Request full dump since some info got dropped
95 struct rtgenmsg msg = { .rtgen_family = AF_UNSPEC };
96 nl_send_simple(ev->sock, RTM_GETLINK, NLM_F_DUMP, &msg, sizeof(msg));
106 uloop_fd_delete(&ev->uloop);
110 static struct nl_sock *
111 create_socket(int protocol, int groups)
113 struct nl_sock *sock;
115 sock = nl_socket_alloc();
120 nl_join_groups(sock, groups);
122 if (nl_connect(sock, protocol))
129 create_raw_event_socket(struct event_socket *ev, int protocol, int groups,
130 uloop_fd_handler cb, int flags)
132 ev->sock = create_socket(protocol, groups);
136 ev->uloop.fd = nl_socket_get_fd(ev->sock);
138 if (uloop_fd_add(&ev->uloop, ULOOP_READ|flags))
145 create_event_socket(struct event_socket *ev, int protocol,
146 int (*cb)(struct nl_msg *msg, void *arg))
148 if (!create_raw_event_socket(ev, protocol, 0, handler_nl_event, ULOOP_ERROR_CB))
151 // Install the valid custom callback handler
152 nl_socket_modify_cb(ev->sock, NL_CB_VALID, NL_CB_CUSTOM, cb, NULL);
154 // Disable sequence number checking on event sockets
155 nl_socket_disable_seq_check(ev->sock);
157 // Increase rx buffer size to 65K on event sockets
159 if (nl_socket_set_buffer_size(ev->sock, ev->bufsize, 0))
165 int system_init(void)
167 static struct event_socket rtnl_event;
168 static struct event_socket hotplug_event;
170 sock_ioctl = socket(AF_LOCAL, SOCK_DGRAM, 0);
171 system_fd_set_cloexec(sock_ioctl);
173 // Prepare socket for routing / address control
174 sock_rtnl = create_socket(NETLINK_ROUTE, 0);
178 if (!create_event_socket(&rtnl_event, NETLINK_ROUTE, cb_rtnl_event))
181 if (!create_raw_event_socket(&hotplug_event, NETLINK_KOBJECT_UEVENT, 1,
182 handle_hotplug_event, 0))
185 // Receive network link events form kernel
186 nl_socket_add_membership(rtnl_event.sock, RTNLGRP_LINK);
191 static void system_set_sysctl(const char *path, const char *val)
195 fd = open(path, O_WRONLY);
199 if (write(fd, val, strlen(val))) {}
203 static void system_set_dev_sysctl(const char *path, const char *device, const char *val)
205 snprintf(dev_buf, sizeof(dev_buf), path, device);
206 system_set_sysctl(dev_buf, val);
209 static void system_set_disable_ipv6(struct device *dev, const char *val)
211 system_set_dev_sysctl("/proc/sys/net/ipv6/conf/%s/disable_ipv6", dev->ifname, val);
214 static int system_get_sysctl(const char *path, char *buf, const size_t buf_sz)
216 int fd = -1, ret = -1;
218 fd = open(path, O_RDONLY);
222 ssize_t len = read(fd, buf, buf_sz - 1);
236 system_get_dev_sysctl(const char *path, const char *device, char *buf, const size_t buf_sz)
238 snprintf(dev_buf, sizeof(dev_buf), path, device);
239 return system_get_sysctl(dev_buf, buf, buf_sz);
242 static int system_get_disable_ipv6(struct device *dev, char *buf, const size_t buf_sz)
244 return system_get_dev_sysctl("/proc/sys/net/ipv6/conf/%s/disable_ipv6",
245 dev->ifname, buf, buf_sz);
249 #define IFF_LOWER_UP 0x10000
252 // Evaluate netlink messages
253 static int cb_rtnl_event(struct nl_msg *msg, void *arg)
255 struct nlmsghdr *nh = nlmsg_hdr(msg);
256 struct ifinfomsg *ifi = NLMSG_DATA(nh);
257 struct nlattr *nla[__IFLA_MAX];
259 if (nh->nlmsg_type != RTM_NEWLINK)
262 nlmsg_parse(nh, sizeof(*ifi), nla, __IFLA_MAX - 1, NULL);
263 if (!nla[IFLA_IFNAME])
266 struct device *dev = device_get(nla_data(nla[IFLA_IFNAME]), false);
270 device_set_ifindex(dev, ifi->ifi_index);
271 device_set_link(dev, ifi->ifi_flags & IFF_LOWER_UP ? true : false);
278 handle_hotplug_msg(char *data, int size)
280 const char *subsystem = NULL, *interface = NULL;
281 char *cur, *end, *sep;
286 if (!strncmp(data, "add@", 4))
288 else if (!strncmp(data, "remove@", 7))
293 skip = strlen(data) + 1;
296 for (cur = data + skip; cur < end; cur += skip) {
297 skip = strlen(cur) + 1;
299 sep = strchr(cur, '=');
304 if (!strcmp(cur, "INTERFACE"))
306 else if (!strcmp(cur, "SUBSYSTEM")) {
308 if (strcmp(subsystem, "net") != 0)
311 if (subsystem && interface)
317 dev = device_get(interface, false);
321 if (dev->type != &simple_device_type)
324 if (add && system_if_force_external(dev->ifname))
327 device_set_present(dev, add);
331 handle_hotplug_event(struct uloop_fd *u, unsigned int events)
333 struct event_socket *ev = container_of(u, struct event_socket, uloop);
334 struct sockaddr_nl nla;
335 unsigned char *buf = NULL;
338 while ((size = nl_recv(ev->sock, &nla, &buf, NULL)) > 0) {
340 handle_hotplug_msg((char *) buf, size);
346 static int system_rtnl_call(struct nl_msg *msg)
350 ret = nl_send_auto_complete(sock_rtnl, msg);
356 return nl_wait_for_ack(sock_rtnl);
359 int system_bridge_delbr(struct device *bridge)
361 return ioctl(sock_ioctl, SIOCBRDELBR, bridge->ifname);
364 static int system_bridge_if(const char *bridge, struct device *dev, int cmd, void *data)
368 memset(&ifr, 0, sizeof(ifr));
370 ifr.ifr_ifindex = dev->ifindex;
373 strncpy(ifr.ifr_name, bridge, sizeof(ifr.ifr_name));
374 return ioctl(sock_ioctl, cmd, &ifr);
377 static bool system_is_bridge(const char *name, char *buf, int buflen)
381 snprintf(buf, buflen, "/sys/devices/virtual/net/%s/bridge", name);
382 if (stat(buf, &st) < 0)
388 static char *system_get_bridge(const char *name, char *buf, int buflen)
394 snprintf(buf, buflen, "/sys/devices/virtual/net/*/brif/%s/bridge", name);
395 if (glob(buf, GLOB_NOSORT, NULL, &gl) < 0)
398 if (gl.gl_pathc == 0)
401 len = readlink(gl.gl_pathv[0], buf, buflen);
406 path = strrchr(buf, '/');
413 int system_bridge_addif(struct device *bridge, struct device *dev)
417 oldbr = system_get_bridge(dev->ifname, dev_buf, sizeof(dev_buf));
418 if (oldbr && !strcmp(oldbr, bridge->ifname))
421 return system_bridge_if(bridge->ifname, dev, SIOCBRADDIF, NULL);
424 int system_bridge_delif(struct device *bridge, struct device *dev)
426 return system_bridge_if(bridge->ifname, dev, SIOCBRDELIF, NULL);
429 static int system_if_resolve(struct device *dev)
432 strncpy(ifr.ifr_name, dev->ifname, sizeof(ifr.ifr_name));
433 if (!ioctl(sock_ioctl, SIOCGIFINDEX, &ifr))
434 return ifr.ifr_ifindex;
439 static int system_if_flags(const char *ifname, unsigned add, unsigned rem)
443 memset(&ifr, 0, sizeof(ifr));
444 strncpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
445 ioctl(sock_ioctl, SIOCGIFFLAGS, &ifr);
446 ifr.ifr_flags |= add;
447 ifr.ifr_flags &= ~rem;
448 return ioctl(sock_ioctl, SIOCSIFFLAGS, &ifr);
460 static bool check_ifaddr(struct nlmsghdr *hdr, int ifindex)
462 struct ifaddrmsg *ifa = NLMSG_DATA(hdr);
464 return ifa->ifa_index == ifindex;
467 static bool check_route(struct nlmsghdr *hdr, int ifindex)
469 struct rtmsg *r = NLMSG_DATA(hdr);
470 struct nlattr *tb[__RTA_MAX];
472 if (r->rtm_protocol == RTPROT_KERNEL &&
473 r->rtm_family == AF_INET6)
476 nlmsg_parse(hdr, sizeof(struct rtmsg), tb, __RTA_MAX - 1, NULL);
480 return *(int *)RTA_DATA(tb[RTA_OIF]) == ifindex;
483 static bool check_rule(struct nlmsghdr *hdr, int ifindex)
488 static int cb_clear_event(struct nl_msg *msg, void *arg)
490 struct clear_data *clr = arg;
491 struct nlmsghdr *hdr = nlmsg_hdr(msg);
492 bool (*cb)(struct nlmsghdr *, int ifindex);
498 if (hdr->nlmsg_type != RTM_NEWADDR)
505 if (hdr->nlmsg_type != RTM_NEWROUTE)
512 if (hdr->nlmsg_type != RTM_NEWRULE)
521 if (!cb(hdr, clr->dev ? clr->dev->ifindex : 0))
524 if (type == RTM_DELRULE)
525 D(SYSTEM, "Remove a rule\n");
527 D(SYSTEM, "Remove %s from device %s\n",
528 type == RTM_DELADDR ? "an address" : "a route",
530 memcpy(nlmsg_hdr(clr->msg), hdr, hdr->nlmsg_len);
531 hdr = nlmsg_hdr(clr->msg);
532 hdr->nlmsg_type = type;
533 hdr->nlmsg_flags = NLM_F_REQUEST;
535 nl_socket_disable_auto_ack(sock_rtnl);
536 nl_send_auto_complete(sock_rtnl, clr->msg);
537 nl_socket_enable_auto_ack(sock_rtnl);
543 cb_finish_event(struct nl_msg *msg, void *arg)
551 error_handler(struct sockaddr_nl *nla, struct nlmsgerr *err, void *arg)
554 *pending = err->error;
559 system_if_clear_entries(struct device *dev, int type, int af)
561 struct clear_data clr;
562 struct nl_cb *cb = nl_cb_alloc(NL_CB_DEFAULT);
565 .rtm_flags = RTM_F_CLONED,
567 int flags = NLM_F_DUMP;
576 clr.size = sizeof(struct rtgenmsg);
579 clr.size = sizeof(struct rtmsg);
588 clr.msg = nlmsg_alloc_simple(type, flags);
592 nlmsg_append(clr.msg, &rtm, clr.size, 0);
593 nl_cb_set(cb, NL_CB_VALID, NL_CB_CUSTOM, cb_clear_event, &clr);
594 nl_cb_set(cb, NL_CB_FINISH, NL_CB_CUSTOM, cb_finish_event, &pending);
595 nl_cb_err(cb, NL_CB_CUSTOM, error_handler, &pending);
597 nl_send_auto_complete(sock_rtnl, clr.msg);
599 nl_recvmsgs(sock_rtnl, cb);
607 * Clear bridge (membership) state and bring down device
609 void system_if_clear_state(struct device *dev)
611 static char buf[256];
614 device_set_ifindex(dev, system_if_resolve(dev));
615 if (dev->external || !dev->ifindex)
618 system_if_flags(dev->ifname, 0, IFF_UP);
620 if (system_is_bridge(dev->ifname, buf, sizeof(buf))) {
621 D(SYSTEM, "Delete existing bridge named '%s'\n", dev->ifname);
622 system_bridge_delbr(dev);
626 bridge = system_get_bridge(dev->ifname, buf, sizeof(buf));
628 D(SYSTEM, "Remove device '%s' from bridge '%s'\n", dev->ifname, bridge);
629 system_bridge_if(bridge, dev, SIOCBRDELIF, NULL);
632 system_if_clear_entries(dev, RTM_GETROUTE, AF_INET);
633 system_if_clear_entries(dev, RTM_GETADDR, AF_INET);
634 system_if_clear_entries(dev, RTM_GETROUTE, AF_INET6);
635 system_if_clear_entries(dev, RTM_GETADDR, AF_INET6);
636 system_set_disable_ipv6(dev, "0");
639 static inline unsigned long
640 sec_to_jiffies(int val)
642 return (unsigned long) val * 100;
645 int system_bridge_addbr(struct device *bridge, struct bridge_config *cfg)
647 unsigned long args[4] = {};
649 if (ioctl(sock_ioctl, SIOCBRADDBR, bridge->ifname) < 0)
652 args[0] = BRCTL_SET_BRIDGE_STP_STATE;
653 args[1] = !!cfg->stp;
654 system_bridge_if(bridge->ifname, NULL, SIOCDEVPRIVATE, &args);
656 args[0] = BRCTL_SET_BRIDGE_FORWARD_DELAY;
657 args[1] = sec_to_jiffies(cfg->forward_delay);
658 system_bridge_if(bridge->ifname, NULL, SIOCDEVPRIVATE, &args);
660 system_set_dev_sysctl("/sys/devices/virtual/net/%s/bridge/multicast_snooping",
661 bridge->ifname, cfg->igmp_snoop ? "1" : "0");
663 args[0] = BRCTL_SET_BRIDGE_PRIORITY;
664 args[1] = cfg->priority;
665 system_bridge_if(bridge->ifname, NULL, SIOCDEVPRIVATE, &args);
667 if (cfg->flags & BRIDGE_OPT_AGEING_TIME) {
668 args[0] = BRCTL_SET_AGEING_TIME;
669 args[1] = sec_to_jiffies(cfg->ageing_time);
670 system_bridge_if(bridge->ifname, NULL, SIOCDEVPRIVATE, &args);
673 if (cfg->flags & BRIDGE_OPT_HELLO_TIME) {
674 args[0] = BRCTL_SET_BRIDGE_HELLO_TIME;
675 args[1] = sec_to_jiffies(cfg->hello_time);
676 system_bridge_if(bridge->ifname, NULL, SIOCDEVPRIVATE, &args);
679 if (cfg->flags & BRIDGE_OPT_MAX_AGE) {
680 args[0] = BRCTL_SET_BRIDGE_MAX_AGE;
681 args[1] = sec_to_jiffies(cfg->max_age);
682 system_bridge_if(bridge->ifname, NULL, SIOCDEVPRIVATE, &args);
688 int system_macvlan_add(struct device *macvlan, struct device *dev, struct macvlan_config *cfg)
691 struct nlattr *linkinfo, *data;
692 struct ifinfomsg iim = { .ifi_family = AF_INET };
693 int ifindex = system_if_resolve(dev);
695 static const struct {
697 enum macvlan_mode val;
699 { "private", MACVLAN_MODE_PRIVATE },
700 { "vepa", MACVLAN_MODE_VEPA },
701 { "bridge", MACVLAN_MODE_BRIDGE },
702 { "passthru", MACVLAN_MODE_PASSTHRU },
708 msg = nlmsg_alloc_simple(RTM_NEWLINK, NLM_F_REQUEST | NLM_F_CREATE | NLM_F_EXCL);
713 nlmsg_append(msg, &iim, sizeof(iim), 0);
715 if (cfg->flags & MACVLAN_OPT_MACADDR)
716 nla_put(msg, IFLA_ADDRESS, sizeof(cfg->macaddr), cfg->macaddr);
717 nla_put(msg, IFLA_IFNAME, IFNAMSIZ, macvlan->ifname);
718 nla_put_u32(msg, IFLA_LINK, ifindex);
720 if (!(linkinfo = nla_nest_start(msg, IFLA_LINKINFO)))
721 goto nla_put_failure;
723 nla_put(msg, IFLA_INFO_KIND, strlen("macvlan"), "macvlan");
725 if (!(data = nla_nest_start(msg, IFLA_INFO_DATA)))
726 goto nla_put_failure;
729 for (i = 0; i < ARRAY_SIZE(modes); i++) {
730 if (strcmp(cfg->mode, modes[i].name) != 0)
733 nla_put_u32(msg, IFLA_MACVLAN_MODE, modes[i].val);
738 nla_nest_end(msg, data);
739 nla_nest_end(msg, linkinfo);
741 rv = system_rtnl_call(msg);
743 D(SYSTEM, "Error adding macvlan '%s' over '%s': %d\n", macvlan->ifname, dev->ifname, rv);
752 int system_macvlan_del(struct device *macvlan)
755 struct ifinfomsg iim;
757 iim.ifi_family = AF_INET;
760 msg = nlmsg_alloc_simple(RTM_DELLINK, 0);
765 nlmsg_append(msg, &iim, sizeof(iim), 0);
767 nla_put(msg, IFLA_INFO_KIND, strlen("macvlan"), "macvlan");
768 nla_put(msg, IFLA_IFNAME, sizeof(macvlan->ifname), macvlan->ifname);
770 system_rtnl_call(msg);
775 static int system_vlan(struct device *dev, int id)
777 struct vlan_ioctl_args ifr = {
778 .cmd = SET_VLAN_NAME_TYPE_CMD,
779 .u.name_type = VLAN_NAME_TYPE_RAW_PLUS_VID_NO_PAD,
782 ioctl(sock_ioctl, SIOCSIFVLAN, &ifr);
785 ifr.cmd = DEL_VLAN_CMD;
788 ifr.cmd = ADD_VLAN_CMD;
791 strncpy(ifr.device1, dev->ifname, sizeof(ifr.device1));
792 return ioctl(sock_ioctl, SIOCSIFVLAN, &ifr);
795 int system_vlan_add(struct device *dev, int id)
797 return system_vlan(dev, id);
800 int system_vlan_del(struct device *dev)
802 return system_vlan(dev, -1);
806 system_if_get_settings(struct device *dev, struct device_settings *s)
811 memset(&ifr, 0, sizeof(ifr));
812 strncpy(ifr.ifr_name, dev->ifname, sizeof(ifr.ifr_name));
814 if (ioctl(sock_ioctl, SIOCGIFMTU, &ifr) == 0) {
815 s->mtu = ifr.ifr_mtu;
816 s->flags |= DEV_OPT_MTU;
819 if (ioctl(sock_ioctl, SIOCGIFTXQLEN, &ifr) == 0) {
820 s->txqueuelen = ifr.ifr_qlen;
821 s->flags |= DEV_OPT_TXQUEUELEN;
824 if (ioctl(sock_ioctl, SIOCGIFHWADDR, &ifr) == 0) {
825 memcpy(s->macaddr, &ifr.ifr_hwaddr.sa_data, sizeof(s->macaddr));
826 s->flags |= DEV_OPT_MACADDR;
829 if (!system_get_disable_ipv6(dev, buf, sizeof(buf))) {
830 s->ipv6 = !strtoul(buf, NULL, 0);
831 s->flags |= DEV_OPT_IPV6;
836 system_if_apply_settings(struct device *dev, struct device_settings *s, unsigned int apply_mask)
843 memset(&ifr, 0, sizeof(ifr));
844 strncpy(ifr.ifr_name, dev->ifname, sizeof(ifr.ifr_name));
845 if (s->flags & DEV_OPT_MTU & apply_mask) {
846 ifr.ifr_mtu = s->mtu;
847 if (ioctl(sock_ioctl, SIOCSIFMTU, &ifr) < 0)
848 s->flags &= ~DEV_OPT_MTU;
850 if (s->flags & DEV_OPT_TXQUEUELEN & apply_mask) {
851 ifr.ifr_qlen = s->txqueuelen;
852 if (ioctl(sock_ioctl, SIOCSIFTXQLEN, &ifr) < 0)
853 s->flags &= ~DEV_OPT_TXQUEUELEN;
855 if ((s->flags & DEV_OPT_MACADDR & apply_mask) && !dev->external) {
856 ifr.ifr_hwaddr.sa_family = ARPHRD_ETHER;
857 memcpy(&ifr.ifr_hwaddr.sa_data, s->macaddr, sizeof(s->macaddr));
858 if (ioctl(sock_ioctl, SIOCSIFHWADDR, &ifr) < 0)
859 s->flags &= ~DEV_OPT_MACADDR;
861 if (s->flags & DEV_OPT_IPV6 & apply_mask)
862 system_set_disable_ipv6(dev, s->ipv6 ? "0" : "1");
865 int system_if_up(struct device *dev)
867 system_if_get_settings(dev, &dev->orig_settings);
868 system_if_apply_settings(dev, &dev->settings, dev->settings.flags);
869 device_set_ifindex(dev, system_if_resolve(dev));
870 return system_if_flags(dev->ifname, IFF_UP, 0);
873 int system_if_down(struct device *dev)
875 int ret = system_if_flags(dev->ifname, 0, IFF_UP);
876 dev->orig_settings.flags &= dev->settings.flags;
877 system_if_apply_settings(dev, &dev->orig_settings, dev->orig_settings.flags);
881 struct if_check_data {
887 static int cb_if_check_valid(struct nl_msg *msg, void *arg)
889 struct nlmsghdr *nh = nlmsg_hdr(msg);
890 struct ifinfomsg *ifi = NLMSG_DATA(nh);
891 struct if_check_data *chk = (struct if_check_data *)arg;
893 if (nh->nlmsg_type != RTM_NEWLINK)
896 device_set_present(chk->dev, ifi->ifi_index > 0 ? true : false);
897 device_set_link(chk->dev, ifi->ifi_flags & IFF_LOWER_UP ? true : false);
902 static int cb_if_check_ack(struct nl_msg *msg, void *arg)
904 struct if_check_data *chk = (struct if_check_data *)arg;
909 static int cb_if_check_error(struct sockaddr_nl *nla, struct nlmsgerr *err, void *arg)
911 struct if_check_data *chk = (struct if_check_data *)arg;
913 device_set_present(chk->dev, false);
914 device_set_link(chk->dev, false);
915 chk->pending = err->error;
920 int system_if_check(struct device *dev)
922 struct nl_cb *cb = nl_cb_alloc(NL_CB_DEFAULT);
924 struct ifinfomsg ifi = {
925 .ifi_family = AF_UNSPEC,
928 struct if_check_data chk = {
934 msg = nlmsg_alloc_simple(RTM_GETLINK, 0);
935 if (!msg || nlmsg_append(msg, &ifi, sizeof(ifi), 0) ||
936 nla_put_string(msg, IFLA_IFNAME, dev->ifname))
939 nl_cb_set(cb, NL_CB_VALID, NL_CB_CUSTOM, cb_if_check_valid, &chk);
940 nl_cb_set(cb, NL_CB_ACK, NL_CB_CUSTOM, cb_if_check_ack, &chk);
941 nl_cb_err(cb, NL_CB_CUSTOM, cb_if_check_error, &chk);
943 nl_send_auto_complete(sock_rtnl, msg);
944 while (chk.pending > 0)
945 nl_recvmsgs(sock_rtnl, cb);
956 system_if_get_parent(struct device *dev)
958 char buf[64], *devname;
959 int ifindex, iflink, len;
962 snprintf(buf, sizeof(buf), "/sys/class/net/%s/iflink", dev->ifname);
967 len = fread(buf, 1, sizeof(buf) - 1, f);
974 iflink = strtoul(buf, NULL, 0);
975 ifindex = system_if_resolve(dev);
976 if (!iflink || iflink == ifindex)
979 devname = if_indextoname(iflink, buf);
983 return device_get(devname, true);
987 read_string_file(int dir_fd, const char *file, char *buf, int len)
993 fd = openat(dir_fd, file, O_RDONLY);
998 len = read(fd, buf, len - 1);
1002 } else if (len > 0) {
1005 c = strchr(buf, '\n');
1018 read_uint64_file(int dir_fd, const char *file, uint64_t *val)
1023 ret = read_string_file(dir_fd, file, buf, sizeof(buf));
1025 *val = strtoull(buf, NULL, 0);
1030 /* Assume advertised flags == supported flags */
1031 static const struct {
1034 } ethtool_link_modes[] = {
1035 { ADVERTISED_10baseT_Half, "10H" },
1036 { ADVERTISED_10baseT_Full, "10F" },
1037 { ADVERTISED_100baseT_Half, "100H" },
1038 { ADVERTISED_100baseT_Full, "100F" },
1039 { ADVERTISED_1000baseT_Half, "1000H" },
1040 { ADVERTISED_1000baseT_Full, "1000F" },
1043 static void system_add_link_modes(struct blob_buf *b, __u32 mask)
1046 for (i = 0; i < ARRAY_SIZE(ethtool_link_modes); i++) {
1047 if (mask & ethtool_link_modes[i].mask)
1048 blobmsg_add_string(b, NULL, ethtool_link_modes[i].name);
1053 system_if_force_external(const char *ifname)
1058 snprintf(buf, sizeof(buf), "/sys/class/net/%s/phy80211", ifname);
1059 return stat(buf, &s) == 0;
1063 system_if_dump_info(struct device *dev, struct blob_buf *b)
1065 struct ethtool_cmd ecmd;
1071 snprintf(buf, sizeof(buf), "/sys/class/net/%s", dev->ifname);
1072 dir_fd = open(buf, O_DIRECTORY);
1074 memset(&ecmd, 0, sizeof(ecmd));
1075 memset(&ifr, 0, sizeof(ifr));
1076 strcpy(ifr.ifr_name, dev->ifname);
1077 ifr.ifr_data = (caddr_t) &ecmd;
1078 ecmd.cmd = ETHTOOL_GSET;
1080 if (ioctl(sock_ioctl, SIOCETHTOOL, &ifr) == 0) {
1081 c = blobmsg_open_array(b, "link-advertising");
1082 system_add_link_modes(b, ecmd.advertising);
1083 blobmsg_close_array(b, c);
1085 c = blobmsg_open_array(b, "link-supported");
1086 system_add_link_modes(b, ecmd.supported);
1087 blobmsg_close_array(b, c);
1089 s = blobmsg_alloc_string_buffer(b, "speed", 8);
1090 snprintf(s, 8, "%d%c", ethtool_cmd_speed(&ecmd),
1091 ecmd.duplex == DUPLEX_HALF ? 'H' : 'F');
1092 blobmsg_add_string_buffer(b);
1100 system_if_dump_stats(struct device *dev, struct blob_buf *b)
1102 const char *const counters[] = {
1103 "collisions", "rx_frame_errors", "tx_compressed",
1104 "multicast", "rx_length_errors", "tx_dropped",
1105 "rx_bytes", "rx_missed_errors", "tx_errors",
1106 "rx_compressed", "rx_over_errors", "tx_fifo_errors",
1107 "rx_crc_errors", "rx_packets", "tx_heartbeat_errors",
1108 "rx_dropped", "tx_aborted_errors", "tx_packets",
1109 "rx_errors", "tx_bytes", "tx_window_errors",
1110 "rx_fifo_errors", "tx_carrier_errors",
1117 snprintf(buf, sizeof(buf), "/sys/class/net/%s/statistics", dev->ifname);
1118 stats_dir = open(buf, O_DIRECTORY);
1122 for (i = 0; i < ARRAY_SIZE(counters); i++)
1123 if (read_uint64_file(stats_dir, counters[i], &val))
1124 blobmsg_add_u64(b, counters[i], val);
1130 static int system_addr(struct device *dev, struct device_addr *addr, int cmd)
1132 bool v4 = ((addr->flags & DEVADDR_FAMILY) == DEVADDR_INET4);
1133 int alen = v4 ? 4 : 16;
1134 unsigned int flags = 0;
1135 struct ifaddrmsg ifa = {
1136 .ifa_family = (alen == 4) ? AF_INET : AF_INET6,
1137 .ifa_prefixlen = addr->mask,
1138 .ifa_index = dev->ifindex,
1142 if (cmd == RTM_NEWADDR)
1143 flags |= NLM_F_CREATE | NLM_F_REPLACE;
1145 msg = nlmsg_alloc_simple(cmd, flags);
1149 nlmsg_append(msg, &ifa, sizeof(ifa), 0);
1150 nla_put(msg, IFA_LOCAL, alen, &addr->addr);
1152 if (addr->broadcast)
1153 nla_put_u32(msg, IFA_BROADCAST, addr->broadcast);
1154 if (addr->point_to_point)
1155 nla_put_u32(msg, IFA_ADDRESS, addr->point_to_point);
1157 time_t now = system_get_rtime();
1158 struct ifa_cacheinfo cinfo = {0xffffffffU, 0xffffffffU, 0, 0};
1160 if (addr->preferred_until) {
1161 int64_t preferred = addr->preferred_until - now;
1164 else if (preferred > UINT32_MAX)
1165 preferred = UINT32_MAX;
1167 cinfo.ifa_prefered = preferred;
1170 if (addr->valid_until) {
1171 int64_t valid = addr->valid_until - now;
1174 else if (valid > UINT32_MAX)
1177 cinfo.ifa_valid = valid;
1180 nla_put(msg, IFA_CACHEINFO, sizeof(cinfo), &cinfo);
1183 return system_rtnl_call(msg);
1186 int system_add_address(struct device *dev, struct device_addr *addr)
1188 return system_addr(dev, addr, RTM_NEWADDR);
1191 int system_del_address(struct device *dev, struct device_addr *addr)
1193 return system_addr(dev, addr, RTM_DELADDR);
1196 static int system_rt(struct device *dev, struct device_route *route, int cmd)
1198 int alen = ((route->flags & DEVADDR_FAMILY) == DEVADDR_INET4) ? 4 : 16;
1200 unsigned int flags = 0;
1203 have_gw = !!route->nexthop.in.s_addr;
1205 have_gw = route->nexthop.in6.s6_addr32[0] ||
1206 route->nexthop.in6.s6_addr32[1] ||
1207 route->nexthop.in6.s6_addr32[2] ||
1208 route->nexthop.in6.s6_addr32[3];
1210 unsigned char scope = (cmd == RTM_DELROUTE) ? RT_SCOPE_NOWHERE :
1211 (have_gw) ? RT_SCOPE_UNIVERSE : RT_SCOPE_LINK;
1213 unsigned int table = (route->flags & (DEVROUTE_TABLE | DEVROUTE_SRCTABLE))
1214 ? route->table : RT_TABLE_MAIN;
1216 struct rtmsg rtm = {
1217 .rtm_family = (alen == 4) ? AF_INET : AF_INET6,
1218 .rtm_dst_len = route->mask,
1219 .rtm_src_len = route->sourcemask,
1220 .rtm_table = (table < 256) ? table : RT_TABLE_UNSPEC,
1221 .rtm_protocol = (route->flags & DEVADDR_KERNEL) ? RTPROT_KERNEL : RTPROT_STATIC,
1223 .rtm_type = (cmd == RTM_DELROUTE) ? 0: RTN_UNICAST,
1224 .rtm_flags = (route->flags & DEVROUTE_ONLINK) ? RTNH_F_ONLINK : 0,
1228 if (cmd == RTM_NEWROUTE) {
1229 flags |= NLM_F_CREATE | NLM_F_REPLACE;
1231 if (!dev) { // Add null-route
1232 rtm.rtm_scope = RT_SCOPE_UNIVERSE;
1233 rtm.rtm_type = RTN_UNREACHABLE;
1237 msg = nlmsg_alloc_simple(cmd, flags);
1241 nlmsg_append(msg, &rtm, sizeof(rtm), 0);
1244 nla_put(msg, RTA_DST, alen, &route->addr);
1246 if (route->sourcemask)
1247 nla_put(msg, RTA_SRC, alen, &route->source);
1249 if (route->metric > 0)
1250 nla_put_u32(msg, RTA_PRIORITY, route->metric);
1253 nla_put(msg, RTA_GATEWAY, alen, &route->nexthop);
1256 nla_put_u32(msg, RTA_OIF, dev->ifindex);
1259 nla_put_u32(msg, RTA_TABLE, table);
1261 if (route->flags & DEVROUTE_MTU) {
1262 struct nlattr *metrics;
1264 if (!(metrics = nla_nest_start(msg, RTA_METRICS)))
1265 goto nla_put_failure;
1267 nla_put_u32(msg, RTAX_MTU, route->mtu);
1269 nla_nest_end(msg, metrics);
1272 return system_rtnl_call(msg);
1279 int system_add_route(struct device *dev, struct device_route *route)
1281 return system_rt(dev, route, RTM_NEWROUTE);
1284 int system_del_route(struct device *dev, struct device_route *route)
1286 return system_rt(dev, route, RTM_DELROUTE);
1289 int system_flush_routes(void)
1291 const char *names[] = {
1292 "/proc/sys/net/ipv4/route/flush",
1293 "/proc/sys/net/ipv6/route/flush"
1297 for (i = 0; i < ARRAY_SIZE(names); i++) {
1298 fd = open(names[i], O_WRONLY);
1302 if (write(fd, "-1", 2)) {}
1308 bool system_resolve_rt_table(const char *name, unsigned int *id)
1312 unsigned int n, table = RT_TABLE_UNSPEC;
1314 /* first try to parse table as number */
1315 if ((n = strtoul(name, &e, 0)) > 0 && !*e)
1318 /* handle well known aliases */
1319 else if (!strcmp(name, "default"))
1320 table = RT_TABLE_DEFAULT;
1321 else if (!strcmp(name, "main"))
1322 table = RT_TABLE_MAIN;
1323 else if (!strcmp(name, "local"))
1324 table = RT_TABLE_LOCAL;
1326 /* try to look up name in /etc/iproute2/rt_tables */
1327 else if ((f = fopen("/etc/iproute2/rt_tables", "r")) != NULL)
1329 while (fgets(buf, sizeof(buf) - 1, f) != NULL)
1331 if ((e = strtok(buf, " \t\n")) == NULL || *e == '#')
1334 n = strtoul(e, NULL, 10);
1335 e = strtok(NULL, " \t\n");
1337 if (e && !strcmp(e, name))
1347 if (table == RT_TABLE_UNSPEC)
1350 /* do not consider main table special */
1351 if (table == RT_TABLE_MAIN)
1352 table = RT_TABLE_UNSPEC;
1358 static int system_iprule(struct iprule *rule, int cmd)
1360 int alen = ((rule->flags & IPRULE_FAMILY) == IPRULE_INET4) ? 4 : 16;
1363 struct rtmsg rtm = {
1364 .rtm_family = (alen == 4) ? AF_INET : AF_INET6,
1365 .rtm_protocol = RTPROT_STATIC,
1366 .rtm_scope = RT_SCOPE_UNIVERSE,
1367 .rtm_table = RT_TABLE_UNSPEC,
1368 .rtm_type = RTN_UNSPEC,
1372 if (cmd == RTM_NEWRULE) {
1373 rtm.rtm_type = RTN_UNICAST;
1374 rtm.rtm_flags |= NLM_F_REPLACE | NLM_F_EXCL;
1378 rtm.rtm_flags |= FIB_RULE_INVERT;
1380 if (rule->flags & IPRULE_SRC)
1381 rtm.rtm_src_len = rule->src_mask;
1383 if (rule->flags & IPRULE_DEST)
1384 rtm.rtm_dst_len = rule->dest_mask;
1386 if (rule->flags & IPRULE_TOS)
1387 rtm.rtm_tos = rule->tos;
1389 if (rule->flags & IPRULE_LOOKUP) {
1390 if (rule->lookup < 256)
1391 rtm.rtm_table = rule->lookup;
1394 if (rule->flags & IPRULE_ACTION)
1395 rtm.rtm_type = rule->action;
1396 else if (rule->flags & IPRULE_GOTO)
1397 rtm.rtm_type = FR_ACT_GOTO;
1398 else if (!(rule->flags & (IPRULE_LOOKUP | IPRULE_ACTION | IPRULE_GOTO)))
1399 rtm.rtm_type = FR_ACT_NOP;
1401 msg = nlmsg_alloc_simple(cmd, NLM_F_REQUEST);
1406 nlmsg_append(msg, &rtm, sizeof(rtm), 0);
1408 if (rule->flags & IPRULE_IN)
1409 nla_put(msg, FRA_IFNAME, strlen(rule->in_dev) + 1, rule->in_dev);
1411 if (rule->flags & IPRULE_OUT)
1412 nla_put(msg, FRA_OIFNAME, strlen(rule->out_dev) + 1, rule->out_dev);
1414 if (rule->flags & IPRULE_SRC)
1415 nla_put(msg, FRA_SRC, alen, &rule->src_addr);
1417 if (rule->flags & IPRULE_DEST)
1418 nla_put(msg, FRA_DST, alen, &rule->dest_addr);
1420 if (rule->flags & IPRULE_PRIORITY)
1421 nla_put_u32(msg, FRA_PRIORITY, rule->priority);
1422 else if (cmd == RTM_NEWRULE)
1423 nla_put_u32(msg, FRA_PRIORITY, rule->order);
1425 if (rule->flags & IPRULE_FWMARK)
1426 nla_put_u32(msg, FRA_FWMARK, rule->fwmark);
1428 if (rule->flags & IPRULE_FWMASK)
1429 nla_put_u32(msg, FRA_FWMASK, rule->fwmask);
1431 if (rule->flags & IPRULE_LOOKUP) {
1432 if (rule->lookup >= 256)
1433 nla_put_u32(msg, FRA_TABLE, rule->lookup);
1436 if (rule->flags & IPRULE_GOTO)
1437 nla_put_u32(msg, FRA_GOTO, rule->gotoid);
1439 return system_rtnl_call(msg);
1442 int system_add_iprule(struct iprule *rule)
1444 return system_iprule(rule, RTM_NEWRULE);
1447 int system_del_iprule(struct iprule *rule)
1449 return system_iprule(rule, RTM_DELRULE);
1452 int system_flush_iprules(void)
1457 system_if_clear_entries(NULL, RTM_GETRULE, AF_INET);
1458 system_if_clear_entries(NULL, RTM_GETRULE, AF_INET6);
1460 memset(&rule, 0, sizeof(rule));
1463 rule.flags = IPRULE_INET4 | IPRULE_PRIORITY | IPRULE_LOOKUP;
1466 rule.lookup = RT_TABLE_LOCAL;
1467 rv |= system_iprule(&rule, RTM_NEWRULE);
1469 rule.priority = 32766;
1470 rule.lookup = RT_TABLE_MAIN;
1471 rv |= system_iprule(&rule, RTM_NEWRULE);
1473 rule.priority = 32767;
1474 rule.lookup = RT_TABLE_DEFAULT;
1475 rv |= system_iprule(&rule, RTM_NEWRULE);
1478 rule.flags = IPRULE_INET6 | IPRULE_PRIORITY | IPRULE_LOOKUP;
1481 rule.lookup = RT_TABLE_LOCAL;
1482 rv |= system_iprule(&rule, RTM_NEWRULE);
1484 rule.priority = 32766;
1485 rule.lookup = RT_TABLE_MAIN;
1486 rv |= system_iprule(&rule, RTM_NEWRULE);
1491 bool system_resolve_iprule_action(const char *action, unsigned int *id)
1496 if (!strcmp(action, "local"))
1498 else if (!strcmp(action, "nat"))
1500 else if (!strcmp(action, "broadcast"))
1502 else if (!strcmp(action, "anycast"))
1504 else if (!strcmp(action, "multicast"))
1506 else if (!strcmp(action, "prohibit"))
1508 else if (!strcmp(action, "unreachable"))
1509 n = RTN_UNREACHABLE;
1510 else if (!strcmp(action, "blackhole"))
1512 else if (!strcmp(action, "xresolve"))
1514 else if (!strcmp(action, "unicast"))
1516 else if (!strcmp(action, "throw"))
1518 else if (!strcmp(action, "failed_policy"))
1519 n = RTN_FAILED_POLICY;
1521 n = strtoul(action, &e, 0);
1522 if (!e || *e || e == action || n > 255)
1530 time_t system_get_rtime(void)
1535 if (syscall(__NR_clock_gettime, CLOCK_MONOTONIC, &ts) == 0)
1538 if (gettimeofday(&tv, NULL) == 0)
1545 #define IP_DF 0x4000
1548 static int tunnel_ioctl(const char *name, int cmd, void *p)
1552 memset(&ifr, 0, sizeof(ifr));
1553 strncpy(ifr.ifr_name, name, sizeof(ifr.ifr_name));
1554 ifr.ifr_ifru.ifru_data = p;
1555 return ioctl(sock_ioctl, cmd, &ifr);
1558 int system_del_ip_tunnel(const char *name)
1560 return tunnel_ioctl(name, SIOCDELTUNNEL, NULL);
1563 int system_update_ipv6_mtu(struct device *dev, int mtu)
1567 snprintf(buf, sizeof(buf), "/proc/sys/net/ipv6/conf/%s/mtu",
1570 int fd = open(buf, O_RDWR);
1571 ssize_t len = read(fd, buf, sizeof(buf) - 1);
1578 if (!mtu || ret <= mtu)
1581 lseek(fd, 0, SEEK_SET);
1582 if (write(fd, buf, snprintf(buf, sizeof(buf), "%i", mtu)) <= 0)
1590 int system_add_ip_tunnel(const char *name, struct blob_attr *attr)
1592 struct blob_attr *tb[__TUNNEL_ATTR_MAX];
1593 struct blob_attr *cur;
1597 system_del_ip_tunnel(name);
1599 blobmsg_parse(tunnel_attr_list.params, __TUNNEL_ATTR_MAX, tb,
1600 blob_data(attr), blob_len(attr));
1602 if (!(cur = tb[TUNNEL_ATTR_TYPE]))
1604 str = blobmsg_data(cur);
1606 if ((cur = tb[TUNNEL_ATTR_DF]))
1607 set_df = blobmsg_get_bool(cur);
1609 unsigned int ttl = 0;
1610 if ((cur = tb[TUNNEL_ATTR_TTL])) {
1611 ttl = blobmsg_get_u32(cur);
1612 if (ttl > 255 || (!set_df && ttl))
1616 unsigned int link = 0;
1617 if ((cur = tb[TUNNEL_ATTR_LINK])) {
1618 struct interface *iface = vlist_find(&interfaces, blobmsg_data(cur), iface, node);
1622 if (iface->l3_dev.dev)
1623 link = iface->l3_dev.dev->ifindex;
1626 if (!strcmp(str, "sit")) {
1627 struct ip_tunnel_parm p = {
1632 .frag_off = set_df ? htons(IP_DF) : 0,
1633 .protocol = IPPROTO_IPV6,
1638 if ((cur = tb[TUNNEL_ATTR_LOCAL]) &&
1639 inet_pton(AF_INET, blobmsg_data(cur), &p.iph.saddr) < 1)
1642 if ((cur = tb[TUNNEL_ATTR_REMOTE]) &&
1643 inet_pton(AF_INET, blobmsg_data(cur), &p.iph.daddr) < 1)
1646 strncpy(p.name, name, sizeof(p.name));
1647 if (tunnel_ioctl("sit0", SIOCADDTUNNEL, &p) < 0)
1651 if ((cur = tb[TUNNEL_ATTR_6RD_PREFIX])) {
1653 struct ip_tunnel_6rd p6;
1655 memset(&p6, 0, sizeof(p6));
1657 if (!parse_ip_and_netmask(AF_INET6, blobmsg_data(cur),
1658 &p6.prefix, &mask) || mask > 128)
1660 p6.prefixlen = mask;
1662 if ((cur = tb[TUNNEL_ATTR_6RD_RELAY_PREFIX])) {
1663 if (!parse_ip_and_netmask(AF_INET, blobmsg_data(cur),
1664 &p6.relay_prefix, &mask) || mask > 32)
1666 p6.relay_prefixlen = mask;
1669 if (tunnel_ioctl(name, SIOCADD6RD, &p6) < 0) {
1670 system_del_ip_tunnel(name);
1675 } else if (!strcmp(str, "ipip6")) {
1676 struct nl_msg *nlm = nlmsg_alloc_simple(RTM_NEWLINK,
1677 NLM_F_REQUEST | NLM_F_REPLACE | NLM_F_CREATE);
1679 struct ifinfomsg ifi = { .ifi_family = AF_UNSPEC };
1680 nlmsg_append(nlm, &ifi, sizeof(ifi), 0);
1681 nla_put_string(nlm, IFLA_IFNAME, name);
1684 nla_put_u32(nlm, IFLA_LINK, link);
1686 struct nlattr *linkinfo = nla_nest_start(nlm, IFLA_LINKINFO);
1687 nla_put_string(nlm, IFLA_INFO_KIND, "ip6tnl");
1688 struct nlattr *infodata = nla_nest_start(nlm, IFLA_INFO_DATA);
1691 nla_put_u32(nlm, IFLA_IPTUN_LINK, link);
1693 nla_put_u8(nlm, IFLA_IPTUN_PROTO, IPPROTO_IPIP);
1694 nla_put_u8(nlm, IFLA_IPTUN_TTL, (ttl) ? ttl : 64);
1695 nla_put_u8(nlm, IFLA_IPTUN_ENCAP_LIMIT, 4);
1697 struct in6_addr in6buf;
1698 if ((cur = tb[TUNNEL_ATTR_LOCAL])) {
1699 if (inet_pton(AF_INET6, blobmsg_data(cur), &in6buf) < 1)
1701 nla_put(nlm, IFLA_IPTUN_LOCAL, sizeof(in6buf), &in6buf);
1704 if ((cur = tb[TUNNEL_ATTR_REMOTE])) {
1705 if (inet_pton(AF_INET6, blobmsg_data(cur), &in6buf) < 1)
1707 nla_put(nlm, IFLA_IPTUN_REMOTE, sizeof(in6buf), &in6buf);
1710 #ifdef IFLA_IPTUN_FMR_MAX
1711 if ((cur = tb[TUNNEL_ATTR_FMRS])) {
1712 struct nlattr *fmrs = nla_nest_start(nlm, IFLA_IPTUN_FMRS);
1714 struct blob_attr *fmr;
1715 unsigned rem, fmrcnt = 0;
1716 blobmsg_for_each_attr(fmr, cur, rem) {
1717 if (blobmsg_type(fmr) != BLOBMSG_TYPE_STRING)
1720 unsigned ip4len, ip6len, ealen, offset = 6;
1724 if (sscanf(blobmsg_get_string(fmr), "%47[^/]/%u,%15[^/]/%u,%u,%u",
1725 ip6buf, &ip6len, ip4buf, &ip4len, &ealen, &offset) < 5)
1728 struct in6_addr ip6prefix;
1729 struct in_addr ip4prefix;
1730 if (inet_pton(AF_INET6, ip6buf, &ip6prefix) != 1 ||
1731 inet_pton(AF_INET, ip4buf, &ip4prefix) != 1)
1734 struct nlattr *rule = nla_nest_start(nlm, ++fmrcnt);
1736 nla_put(nlm, IFLA_IPTUN_FMR_IP6_PREFIX, sizeof(ip6prefix), &ip6prefix);
1737 nla_put(nlm, IFLA_IPTUN_FMR_IP4_PREFIX, sizeof(ip4prefix), &ip4prefix);
1738 nla_put_u8(nlm, IFLA_IPTUN_FMR_IP6_PREFIX_LEN, ip6len);
1739 nla_put_u8(nlm, IFLA_IPTUN_FMR_IP4_PREFIX_LEN, ip4len);
1740 nla_put_u8(nlm, IFLA_IPTUN_FMR_EA_LEN, ealen);
1741 nla_put_u8(nlm, IFLA_IPTUN_FMR_OFFSET, offset);
1743 nla_nest_end(nlm, rule);
1746 nla_nest_end(nlm, fmrs);
1750 nla_nest_end(nlm, infodata);
1751 nla_nest_end(nlm, linkinfo);
1753 return system_rtnl_call(nlm);